In this episode of Elixir Mix, the panelists talk with Alvise Susmel about building Elixir systems that leverage Python image detection on video frames. We cover Ports vs NIFs, using platforms for their strengths, cool embedded hardware, displaying real time results in Phoenix or Scenic, and much more!

Links

Welcome to Elixir Mix, your Elixir podcast talking with members of the community. My name is Mark Erickson, and today we're joined by Sophie de Benedetto Hey, guys. And our guest, Alvisa Susmel. Hello. Thanks for having me.

I'm glad you could come on. So this is an exciting topic for me because it's something I find fascinating. I think whenever I hear about this, I think, wow, that's super advanced and futuristic, and I'd have no idea how to do it myself. And so we've invited Alvisa on to help talk about how to do this. And and so, like, what we're talking about is using, like, image recognition with Elixir and really cool stuff like that.

So, first of all, Aviza, maybe you could tell us, like, where you work and a little bit about yourself, what kind of problems you're solving. Yeah. Sure. So in the last 5, 6 years, I've been a CTO in a London hedge fund, and I'm still working from them as a consultant. And, at the moment, I'm consulting and running poeticcoding.com, which is an educational site, which is, at the moment is mainly focused on Elixir and Phoenix, and I'm working to make some free and paid Elixir and Phoenix courses.

And, my current clients are from finances. So, the problems I'm facing are similar to what I've faced so far at The Hedge Fund. And so to describe what kind of problems I had to face, we at the hedge fund, we've designed, 3 different architectures to, mainly process data in real time. So the first was to process data, for real time trades coming from different exchanges for 100 of different products. So products are financial products, different assets.

And the goal of this platform, is to use the data to run our trading models. And in this case, we had, we have a lot of Python code because all the data science framework, there are really great data science framework there. And another, platform was to, is to process, financial tweets in real time. So we get a huge amount of tweets in real time. We run our machine learning models to cluster these tweets, to understand which company they they refer to.

And and then, the system generates a minute by minute sentiment for each company, which is useful in different trading situations. And we have also another platform, which is an internal platform for research. It's like, a set of research tools we use to exchange information about research. So what they have in common is, the need to process real time, let's say, events and to especially to self heal, because we need, we need to stay up. Obviously, it's not a 100%, but we need to stay to be reactive to any kind of anomaly and, to process, trades as far as fast as we can.

Nice. So you mentioned in there, like, the need to leverage other, libraries or languages outside of, you know, Core Elixir. And it seems like in today's development environment, that seems to be increasingly the case because you have, like, you'd mentioned data scientists who are using their own set of tools, and they already have these libraries that are being built up by a whole community of people, and a lot of those tend to be in Python. And, historically, just, as web developers, I think we you know, you're you're accustomed to having to work with multiple languages because you have a front end, which might be written in JavaScript, and a back end, which is written in something else. Some people do a pro you know, taking Node as a a back end, but, you know, we we have Elixir or you've done Ruby on Rails or Java or something else.

And then you have mobile on the front end. You know, you're dealing with, you know, mobile frameworks and mobile languages and different platforms. So it's like we are kind of in this area, this environment where we have to deal with multiple types of tools, multiple communities. And so one of the things I think is interesting is this whole idea about how Python has a lot of these libraries for doing, like, image recognition, for doing, you know, like, where you know, be it Python or not, but I'm I might be using GPUs to do accelerated computing. And, so what I loved about your article is that you're you're totally acknowledging that.

Right? That there is stuff that we need to use that's not in Elixir. So we we want to basically try to leverage the benefits of each the strengths of each language and each platform to do what they're best at. So maybe you can tell us a little bit about this, blog post that you wrote and kinda give us an introduction to this topic of what you're trying to do. Yes.

Sure. The, so the blog post is about, real time object detection, and the idea of using real time object detection in Phoenix, well, in Elixir and then using Phoenix to render the result. So obviously, the idea of the of the blog post is not to reinvent the wheel. It's actually to use something, that is already there. So, as I said, there are great frameworks in Python and, is there are also high level libraries like a CVLIB, which uses OpenCV under the hood.

And it's super easy to use and you can just pass an image to this, to a function and this function returns a list of detected objects and the coordinates of these objects. So in the in the article, I actually go through the idea of interfacing and trying to take advantage of this library inside Elixir. And I went through different ways of of communicating with, with Python. Well, the simplest one is to just launch, just run, the the Python process. The problem of this is that to, for example, in this specific case, we have, a neural network, which is a deep neural network.

Well, actually, a convolutional neural network. And to load this model, it takes around 2, 3 second on a MacBook Pro. And, obviously, we can't run this, this, scrape there for each single frame or each single image we want. And, so we need a long running process. That means we, we keep the the model in memory and and we keep the Python process in memory and we control it via something is called a port.

So a port in, in Elixir and in Airline, it's a mechanism to launch, an operating system process which is external to the BIM. And this brings a lot of advantages. Well, first, if the process crashes, it doesn't bring down the BIM. So it's something external and, we can communicate with this process via message passing and the standard IO. And what I do, through the article is to, is to use ports to build, to build, this communication to, with, with this, Python framework and be able to link the camera from, from the web browser, take the frames from the web browser, send this frame across a WebSocket to a Phoenix channel, and then Elixir sends, these frames to, the Python side detect which actually runs the real detection.

And, and, yeah, the the thing is it's so easy to use this, approach to bring and to use to take advantage of machine learning. And since Python is so, so far on the machine learning side, actually, one of the reason Python has a huge, adoption rate is because all these frameworks, in the last 10 years, the adoption rate increased a lot, but because this framework's not because the the language itself. And, yeah, to me, to me, I think Elixir would be great. I actually would prefer to control, a machine learning library with Elixir rather than Python with pipes and struct and, like, generate a struct with which is like a a job I want to run, a machine learning job I want to run, and then, and then send this job to to a Python to a Python, process, with with a part or with other solutions, like, there are other ways, like, EPMD. So the, is, so there is a library called, if I remember correctly, Pyralang, and, the it's possible to, to create a Python node, just to say there are other ways we can interface, with the with the Python process.

So one of the ways, if I can just kind of clarify the way I understand ports to work. Yeah. I have used ports before, and, in in my case, I was talking to we needed some you know, we're migrating a Ruby on Rails monolith to Elixir, and so there's some things that Ruby still did best because of libraries or whatever. Now I don't wanna reimplement an entire library just so I can have this little piece of functionality. So as ports as I understand it, like, what I'm able to do is I can, start up the process, the OS level process that is running Ruby in my case or Python in your case.

And so you're like, you were describing it up, like, as 2 to 3 second load time just to load everything that it needs for the, for doing the memory yeah, for doing its processing. And so once that load is done, then it's just basically it's, messaging through, like I think it's even just standard out kind of just directly kind of talking, through the OS to the other process. Not even through, like, an HTTP kind of, you know, port, like, you know, web ports or anything like that. It's not a web server. It's just talking directly to it.

So that has a a cost, I guess, in terms of serialization about how do I actually communicate and how do I serialize my data to send it across to this other process. But but that's one of the benefits is, it's it can now be supervised by the beam. Right? So if something goes wrong in my library and it crashes, Elixir can respond to that. Right?

Have you is that something you've, been able to see as well? Yes. Absolutely. This is exactly one of the advantages, and with ports, especially if we wrap a port, if we wrap a Genserver around the port, it becomes super easy to, to supervise it. So, yes, in the article, I what I do is to wrap this port with the with the GenServer, and it's possible to run like, to start monitoring this port.

So when the process crashes, we just receive a message to the owner process, which is an exit message. And, so in this case, we can deal inside the GenServer, and we can just, like, rerun the a port without letting the supervisor do that, without, having to delegate this to the supervisor, or we can just decide to not handle the exit process the exit message, and what happens is that the the the GenServer process just crashes. And if it's supervised, it's restarted again. Another, another advantage is is that of this wrapping, wrapping a part with the GenServer is that we can only the owner so only the process that starts the port can communicate with the port. So can send a message which is propagated via, standard input to the to the Python process and the same as receiving messages from the Python process.

So only the owner can do this messaging. So if we want to use a port, and let's click it's not shared, but, if we want to use this port and send messages to this port from many processes, we need a GenServer that is the owner and takes the ownership of Dysport. So I think most of the cases is better to use a GenServer, I mean, especially in this case. And also another advantage is that if, like in this case, if we want to scale if we want to scale horizontally, if a port is embedded, is handled in, via Genserver, it's easy to spawn a pool of distributed, Genserver workers. Yeah.

I just wanna point out how kind of incredible that is and how Elixir's flexibility around, like, Interop, in this case with Python, is so powerful because what you're doing is you're leveraging, like, the concurrency and the ability to manage processes that Elixir gives us and still getting, like, that powerful bit of Python functionality that is best suited to do that image detection. And that's why I kinda think it's fun to say, like, oh, Elixir is kind of good at everything because in a way it is, because it's good at using the things that are better at the thing it can't do. And that's really awesome. Yeah. It's, it's a fantastic glue in these cases is well, first, is I think the the language itself is is great.

So most of the time, I prefer to handle these kind of things and to glue things with Elixir. And at beginning, I thought that this part mechanism could have huge limits. I at the beginning, I thought, okay, if I send because the experiment I did, well, one of the experiments I did is to, was to, send row frames, like, at 30 frame per second. So each frame is around 3 megabyte. So I was sending, around, 100 megabyte per second, and, I thought, okay.

Maybe maybe I could have huge delays because there is messaging. Yeah. There is IO. But, actually, each single message was was sent. The time, the round trip time I, measured is, like, half millisecond for each single frame, which is, I mean, nothing, especially if we want to run, a real time object detection at, 30 frame per second.

I mean, it I was really impressed by how faster, is this mechanism and, yeah, how easy is to take this approach and scale horizontally, especially when I when when the port is embedded in engine server, then we can use all the advantages of Elixir, all the libraries like, like, pool buoy or other libraries and supervision and is I mean, almost we get everything for free. Yeah. I love how Sophie kind of described that too because, I do think that is a strength of Elixir and and the Beam in particular. It's just to say that it is a great, interoperability messaging kind of platform. So that it's, like, it is the way I can manage to say, these are the things I want done, and then I can push that out throughout, you know, in a distributed way out to the workers who this one might be Rust, and it's doing something, and this one might be Python, and it's doing something.

And then bring all those back and be able to aggregate and report and and and do everything like that. So, like, it it really kinda comes back to you. It's like, wow. You know, it's kind of like this telephone communication kind of system. And it's like, you know, it's like, wow.

Who'd have thunk? So it's it's kinda fun. But, what I love is, like, in my case, except for, like, a couple examples like I gave with, like, Ruby where I was needing to go to something because of a, an a library. It's a gem that I needed to support for. Otherwise, it's like I don't I don't have any personal needs where I need to go out to those other things.

I don't have performance requirements where I say, I need to go to Rust. I don't I'm not doing anything with, right now with, machine learning. We'd like to at some point in the future, but, you know, at some point, that's where I will go, and I will be interoperability kind of talking with Python. So I love that I can do it, but I don't have to do it yet. Elixir still does everything I need to right where I am right now.

So Yeah. I think it's also, it's also kind of like a a useful case to make or argument to have in your back pocket when you're dealing with adoption. You know, if you're trying to convince your team or or colleagues to use Elixir for a particular project and, you know, people are looking down the line and they're thinking, well, what about when we need something that Python is better suited for? Or what about when we need to solve this problem that, you know, typically, folks may reach for Rust for? You can kind of try this out and say, like, we can use Elixir now so that we can move fast, so that we can leverage, like, a nice design so that we can take advantage of all the fantastic elixir things around concurrency and fault tolerance.

And when we need something else, when we need a tool that's better suited for it, we haven't backed ourselves into a corner. We're not in a place where we need to, you know, spin up a separate service in another language and framework and then figure out what this communication mechanism would look like. Like, I think one of the things that you, mention in your article, Alisa, is that, you know, you could have reached for HTTP communication, you know, built some API endpoints where you're gonna communicate between your Elixir Phoenix app and, you know, this this Python application, but we don't have to. We don't need that overhead. We don't need that complexity.

Ports are one way, among some others, that Elixir just makes it super, super easy to enact that kind of communication. Yes. Compared to, for example, HTTP, which is obviously the first, I mean, the first thing that came to my mind when I wanted to do something like this. And, the problem is supervision, and especially on embedded devices. I mean, if I want to run this thing, real, real time object detection system that is that does something if it finds some objects in in the pictures, in the frames coming from the camera.

I have and if I run, for example, a Python worker that has Flask, like an HTTP, server. I mean, usually, most of the time, especially on an embedded device, I want to supervise this process or this worker. And if I'm able to supervise it, via Elixir, I'm much happier, especially because this means I don't have to, well, I know what what what's happening ex in inside Elixir. So inside Elixir, I know if my workers are fine or not, and I don't have to install some other services like, well, I don't know. Kubernetes may be not in an embedded device, but, it's something that I could, run on a on a in different in a different case if I want to, scale easily and supervise different services.

So this parts makes this much easier. And another solution, as Mark said, we we another solution to communicate, for example, like with with Rust would be, NIFs. So I went through also that path. And, so YALO, which is, it's an acronym for, you only look once, which is the algorithm behind, the object, real time object detection. This is state of the art, object detection system, which is with a real a really, simple with NVIDIA GPU with, it's not cheap, but, around the $500 GPU, you can detect, objects at a 30 frame per second.

And the thing is, the the creator of this, algorithm, they, he did, the c version, c and CUDA version. So they said, okay, maybe I could do a NIF. So first, it's so far easier to, do to use a PORT with a Python high level library than create a NIF and c and trying to interface with to to to bind to create a binding to this library. And, this the but the main thing, what happened is that, the first time I compiled, there was an error in the my c, nif, and, obviously, it crashed. The problem is that, everything crashed.

The beam crashed. And, so, yeah, there are ways to deal with it. Well, first is use Rust. The thing is, I didn't find anything. I mean, there were some libraries, some bindings with OpenCV, with Rust, but the things went quite quite complicated quite easily.

So I said, okay. Ports is far better to me. I mean, I'm not I I I tried many things, but, if I, if I would go back, I would just, use ports in this case in this case because the detection time is still around the 20 millisecond, which is reasonable time, to wait, to delegate a job to a Python process. Obviously, if I just want to do a sum from for 2 floats, a part doesn't isn't isn't isn't the best way because just this messaging, this it it it costs the time. But and in that case, maybe it's better to to use, to use a NIF.

But, for things that are longer that than few milliseconds, parts is easier and, safer, and, safer than CMM. And, yeah. So and, and and also is we were able to just use, a high level library rather than something, with a lower level. I think it's funny. The the library called Yolo, you know, I I I thought it was, like, you only live once, but I I can't that can't be it.

So that's really cool. It's like you only look once. But what I love about your article and I just wanna encourage you, dear listener, to check out the article because if you if if this is an interesting topic to you at all in doing image detection and you're just kinda like like me, like, I'm a noob at this, this is an awesome article because Alviso has put a ton of effort into this. It is detailed. It has you know, one of the things I just love watching in this is the real time ish kind of updates of as it's classifying, you know, video.

And it's like he holds up a remote, you know, water bottle, and it's like, oh, and it's drawing boxes around things. And as he gets up and walks around and how it's following, you know, classifying a person, it's like, it's really cool. So I was curious as to what kind of you've mentioned, like, the the idea of doing something embedded. Is this a personal project, something you're kind of playing with and exploring? Like, what kind of is driving this?

Yes. So there are, 2 goals. So, yes, it's a personal project, but it's driven, from, actually, business needs. So, I worked, with Python in most of the time in the last 5, 6 years, Python and well, in the last 3 years, Elixir. And I always needed to to deal with this fight.

Well, at the beginning, I thought it was a fight. Oh, but there is this on Python. I would like to have it in an exterior. I really don't like this to it's not that I don't like Python, but I prefer to write an exterior. So I started actually to find ways to, bring different kind of problems, more on, like, historical, so list of historical prices, volumes of trades.

So what I wanted to find is that, like, a generic, generic way to deal with this kind of interactions between Elixir and, and, and Python. So the best way was to find a hard problem. I mean, hard in in the sense of processing something like I mean, this model is one of the, toughest on the processing side. And, it's it's so this, Yolo needs to be to run Yolo at a 30 frame per second, we need to be, fast not only on the processing side of Yolo. I mean, that obviously especially if we take this function of the high level library, there's there is there isn't anything we can do.

But what we can do is to work on the boundaries. So I said, okay. This is a great problem also to find that, like, a generic way to handle, this inter interaction with Python, also to deal with other things I had in mind, like, classification, of, a series of, prices. So this is actually what driven it's a mix of personal and business, and then I got hooked by the the problem itself, and I started to say, okay. Oh, but there is this, Jetson Nano, which is an NVIDIA device, embedded device.

It's a $99, and is an embedded device, which, is powered by, the the power supply is, if I remember correctly, 10 watts. And, the cool thing is that it has an an NVIDIA GPU, so we can run a TensorFlow GPU or the CUDA version of the, of the yellow, of the yellow, convolutional neural network, which this means it it runs much, much, faster than on a CPU. So I said, okay. That's great. So now that I have, a Genserver and that I that runs this detection, along with the Python process, what if I buy few of these devices and buy the devices, and I link them, via, Elixir, distributed Elixir, distributed Airline?

So this means each single device runs a worker. So each single device is a node, which runs a worker. And one of these is a master that has a camera and actually use uses the other devices to spread the load, of this classification, of this detection, across different all the devices. And, this is what I did. Actually, I bought 2 devices because I don't didn't want to spend too too many dollars on this.

But, what I saw, actually, I linked also, my computer to the to the to the cluster, and it's it scaled horizontally, super easily. I just needed to do something like a management module, which which does something like a round robin. So, it knows which node is, which node and a worker is busy and which one is free. So as soon as it receives, the it's like a broker. So it receives the frame, knows where to where to send it, and it was super easy.

The thing is with the Elixier, it was super easy, and I said, okay. If I let's see if I want to do it in Python. It's not the it's absolutely not that easy. It's not there are so many free things in in Elixir when it comes to scaling, horizontally, in a distributed manner that, it's, it's amazing. That's cool.

So, yeah, you have a link to this, and I've included a link to in the show notes to this NVIDIA Jetson Nano device, which is looks like it retails for about $100 US, which which I think is super cool that you can do, like, CUDA cores on this little super embedded thing and have a little cluster of them and have workers and farm out, you know, work, which is like you think of, like, okay. Well, if I was going to actually do this, you know, that is the kind of, device, that I could sell and have, like, in the office area that is processing the sensor data and and the the images that are being captured and doing all of my processing. So very cool. I had not seen anything like that. Didn't know that was available.

You know, it's like Raspberry Pi is the the thing that everyone kind of talks about because it is the most approachable place to start. But, yeah, when you're talking about machine learning, you're wanting to go, like, CUDA cores and and using the libraries that are already there. So very cool. Well, we are coming about about up to our time. Is there anything else you want to mention before we transition?

Down on my side? One other thing we haven't touched on was just that you had mentioned in your articles and just the idea of, like, also using Scenic. Oh, yeah. Okay. So maybe you could talk about that for a moment.

Yes. The, the first thing I I, I I tried is to use a a phoenix to, to render especially to render the results. So, because I needed to, get frames, as as easy as I could from from the camera. So I said, okay. Let's try with Phoenix, especially because I can use it also to render as, the the frames and the result with the SVG.

Obviously, this is not the best way. It's the easiest way. It was the easiest way. It's not the best way because there is this, because frames are frames are sent around from Phoenix and from the browser, and the browser sends the the frames to, as a base 64 encoded. We have to decode them, send to the Python worker sites.

So what I did is to say, okay. I I saw that the throughput I could get, with parts is great. And, so I could actually use Python and OpenCV to get the frames. So to get the frames directly from the camera, especially this is great if we use it, with, on embedded device. And what I do well, the first advantage is that, OpenCV, works well, to get the frame.

We have the frame in memory, and the representation is a NumPy, matrix. NumPy is a is a is a library in in Python, to, deal with matrices. And, the cool thing is that we don't need we have this image in memory. We don't need a it's a row, representation of the image, so we don't need to send send the image, to other processes. We just need to run the classified the yellow, object detection.

And, what I, said at the beginning, I said, okay, maybe there will there will be delays and, compared to the compared to the OpenCV renderer. But, actually, what I saw is that with Scenic, which is a framework, to create applications, desktop applications in in in Elixir. With Phoenix, sorry, with SINIC, I was able to, receive, the the frames from, from from the Python process, from OpenCV row, as a binary, and I was able to take this binary without doing any manipulation, any editing, any, and using SINIC to render this frame directly into into the window without any processing of the binary, which is was great. So, yeah, I think this could work. It's still something I have to try.

I think this, could work well in embedded device where we are running this, object detection system, and we actually want to see the result on another device. So we have our embedded device. So with the camera, it runs a Cenac. And the cool thing with Cenac, we are able to see remotely the result, the window. So it's something I still have to try, but I think it should work well.

Nice. That is very cool. I love the idea that you can just like, Scenic can just, you know, display raw data coming in, don't have to process it and convert it in any way, and just kinda, like, be able to render it. So that is very cool. So awesome stuff that people can take advantage of and check out and look at.

So if people are wanting to kinda get in touch with you and follow more about this topic, where should they go to do that? So, the site where I, where I write my blog post is poitcoding.com, and I write articles, mainly about, Elixir and Phoenix. Awesome. So we will also have links to that in the show notes. Check that out.

And also where you are on Twitter, which is your name. Well, let's go ahead and transition to PIX. Sophie, do you have one you can share? Yeah. I do.

So I recently started going through this book called hold on. Let me see if I can find it in our picks section. Black Hat Go. So I'm pretty new to Go, but I'm starting to use it, at work and just kind of plugging through and and learning what I need to learn to kinda get stuff done in my actual job. So this has just been, like, a really fun read to go a little bit further and to sort of explore, some of the things that Go can do and some of the things that, we can learn about, you know, the Internet and how it works using using this language and using these frameworks.

I'm not super far into it yet. I'm only in chapter 2, but for somebody that, again, is relatively new to Go, it's super approachable. It's been really cool. It's, you know, it's very security oriented. You're kind of learning.

You know, you're not really learning how to be a black cat hacker. That's not like a book that you're gonna buy on Amazon. You know, you're learning, to improve your offensive security skill set, which is always an area that I wanted to dive a little bit more into. So, so far, it's been super fun, and I'm definitely recommending it. My other pick is not programming related.

It is a Netflix reality show that is taking over the Internet. You may have heard of Love is Blind, anyone? I'm gonna try to keep this short because I am obsessed with it. The premise of Love is Blind is that these people are dating each other in these pod like rooms where you cannot see the other person. There's, like, a frosted glass pane, in between them, and the idea is that they wanna get married.

So as many proposals that come out of this dating situation, they're then allowed to meet. They're sent on, like, a vacation. They meet each other's families. They move in together, and then they see if they're gonna actually get married. Their goal is to get married.

And I started watching it because it sounds totally nuts and really fun, which it is, but it's also a really fascinating, just, like, study of human behavior. I can't say enough good things about it. It's totally wild, and I really recommend it to basically anyone. Please watch Love is Blind. You don't regret it.

Oh, that's interesting. Hosted by, Nick Lachey of 90 8 Degrees, I should add, which is very important. Very cool. That is I've not heard about that one. Alright.

So the my pick is, it's a it is a command line, little tool that was created. It's, to make it look like you're doing some really cool stuff on your computer. Right? It's it's just for show. It's actually called Hollywood, but it is it's actually been made appearances in television shows and movies and things.

So, like, if you wanna look, like, super elite, you know, you're gonna have, like, your image detection going on on one screen with, like, as things are moving around and being and on the other screen, you've got Hollywood going. And so you can check out their the website. It's it's really cool because it you can actually run out of Docker and stuff like that, so you don't actually have to install anything. And, but, what it does is it opens up multiple tmux panels with then it has lots of techno nonsense stuff going on, plus some real stuff like speed tests, directory tree listing, device listing, you know, off of your actual computer, you know, generating PGP keys, you know, all this stuff. It's all console based.

It's just really fun. Just just fun to I don't know. I think it's a cool little toy. But, that's it for me. Alviso, how about you?

So, the, I want to mention, an article, from, Sasha Yurick and, the, which is, outside elixir, which is an article that helped me a lot to see, to use ports. And I think it's a really great read. And the the second thing is is a book. And actually this book, is, it's something I was reading. It's that fantastic book, one of the best books I read in the last 2 years.

The name is, Designing Data Intensive Applications. And from, the writer, the author is Martin Clapman. It's a quite big book, and it goes from the how database databases are written, how they store data in files, pages, how to use logs. And the reason why, this is in, has been an important book to me is because, I started a blog my blog, actually, trying to implement something, a database, a log database, that was explained in this book, and I tried to to do it in Elixir. And it was so easy to do in Elixir, that a key value store based on logs, right ahead logs.

Something simple, but it's actually one of the first articles. So, it's a great read, and also it deals he deals also with them. He explains the distributed databases, all the issues, how they also deal with the different issues. So great. Great.

And the last thing is, so I follow you, guys, on the on the on the movie side, is something I watched recently. It's called dark, and is time traveling. It's I think if if I remember correctly, it's, is based in, is is in Deutschland. I think it's, and, it's a great, TV series, about time traveling, and the consequences of time traveling. And I'm, really passionate about this topic.

And it's a great it's yeah. It was a great watch. Oh, cool. Alright. So I give a plus one to the, Sasha Yurek's article outside Elixir.

That is that when I was getting into ports, that was, like, super helpful for me as well. So awesome. Good stuff there. Alright. Well, thank you for coming on Alviso.

I had a great time talking with you about this. And, thanks a lot, guys, for having me. Alright. Glad you could come on. And that's it for today.

Thank you for listening, and we hope you'll join us next time on Elixir Mix.