transcript for Mostly Erlang - episode 019 Elixir With José Valim / October 7, 2013

mostly-erlang-019-elixir-with-jose-valim-20131007.txt

# --------------------------------------------------------------------------------------------
# Mostly Erlang - episode 019 Elixir With José Valim / October 7, 2013
#
# guests:
#   - Joe Armstrong (@joeerl)
#   - Robert Virding (@rvirding)
#   - Jose Valim (@josevalim)
#   - Fred Hebert (@mononcqc)
#   - Eric Merit (@ericbmerritt)
#
# generated in Livebook using {:kino_bumblebee, "~> 0.5.0"}
# with speech-to-text - Whisper (large v3 multilingual)
# audio source: https://mostlyerlang.wordpress.com/2013/10/07/019-elixir-with-jose-valim/
# --------------------------------------------------------------------------------------------

(Start of transcription)
00:00:00-00:00:05:  Elixir Sips is a screencast series that will take you from Elixir newbie to experienced practitioner.
00:00:05-00:00:10:  If you're interested in learning Elixir but don't know where to start, then Elixir Sips is perfect for you.
00:00:11-00:00:15:  It's two short screencasts each week between 5 and 15 minutes.
00:00:15-00:00:26:  Elixir Sips currently consists of over two hours of densely packed videos and there are more every week. Elixir Sips is brought to you by Josh Adams, expert Rubyist and CTO of software
00:00:26-00:00:32:  development consultancy, iZotope 11. Elixir Sips, learn Elixir with a pro. Find out more at
00:00:32-00:00:48:  elixirsips.com. Hello, and welcome to Mostly Erlang, episode number 19 on Elixir. I'm Brian Hunter. I'm guest hosting for Zach. And we are joined with Simon and Fred, our regulars. And we also have Joe Armstrong,
00:00:48-00:00:53:  Eric Merritt, Jose Valim, and Robert Verding. And so if we could go around and do a bit of intros,
00:00:53-00:00:57:  I've introduced myself. So Ryan Hunter out of Nashville, Tennessee, Firefly Logic,
00:01:09-00:01:09:  and how about Simon and Fred? I'm the Simon. I'm the co-chair of the O'Reilly Open Source Conference. I'm looking for ways to get functional programming further out in the world to a lot more people.
00:01:12-00:01:13:  And so I've written Introducing Erlang and Introducing Elixir.
00:01:14-00:01:14:  Okay, great. Fred?
00:01:15-00:01:15:  I'm Fred Ebert.
00:01:26-00:01:26:  I'm working with Heroku right now on the routing team, and I'm learned use of Erlang for great good. Okay, and Joe? I'm Joe Armstrong.
00:01:27-00:01:27:  I wrote Programming Erlang,
00:01:29-00:01:29:  and I wrote the first Erlang compiler,
00:01:30-00:01:32:  and I developed Erlang.
00:01:33-00:01:33:  And Eric?
00:01:34-00:01:35:  So I'm Eric Merritt.
00:01:46-00:01:46:  I wrote, well, one of three authors of Erlang and OTP in action, and I've been in the community for for a long time. Cool. And José? Hi, I'm José Valim.
00:01:48-00:01:49:  I'm creator of Elixir,
00:01:50-00:01:53:  and I'm also co-founder of Platform Attack Consultancy in Brazil.
00:01:54-00:01:54:  Cool.
00:01:54-00:01:54:  And Robert?
00:01:55-00:01:56:  Hi, I'm Robert Verling.
00:01:57-00:02:10:  I, well, was one of the co-founders of Erlang Solutions. Okay, perfect. So we have a panel of folks that have implemented languages on the Erlang VM
00:02:10-00:02:12:  and so this is going to be a real treat here.
00:02:12-00:02:17:  But I'd like to start off with Jose and just kind of get sort of the elevator pitch
00:02:17-00:02:20:  or the summary of what Elixir is.
00:02:21-00:02:45:  Well, that depends how long is the elevator trip, but I think the really short one, it's easy. Elixir is a language that runs on the Erlang virtual machine, and that that's our strongest asset.
00:02:50-00:02:51:  So it's about running our code in the Erlang virtual machine.
00:02:53-00:02:53:  And we, of course, we add our own twist.
00:02:58-00:02:59:  We focus a little bit on having some productivity-related tools,
00:03:03-00:03:03:  our flexibilities in the language, and also extensibility.
00:03:06-00:03:08:  But we can expand on those as we go.
00:03:12-00:03:12:  I'm really curious about your background and how you came to this point.
00:03:15-00:03:15:  Like, how did you decide to write a new language on the Erlang VM?
00:03:19-00:03:19:  Your background is a committer on the Rails project, and you can kind of just fill us about the trajectory.
00:03:20-00:03:21:  I think that's a really interesting story.
00:03:28-00:03:35:  Okay. really interesting story okay uh uh joe when did you write the the first the the air link book with pragmatic programmers oh that wasn't the first time but that was i'd have to think about 2007
00:03:35-00:03:43:  something like that yeah august 2007 i think is yeah it about that time it was when like we i
00:03:43-00:03:46:  started hearing more about airline because pragmatic programmers
00:03:46-00:03:52:  is very influential in the in the ruby community and i had an idea about airline i i i glanced over
00:03:52-00:03:58:  the book but it was uh when i read uh seven languages seven weeks from blue state which
00:03:58-00:04:13:  is an excellent book and then uh i read the book and it's talking about all the different languages, Scala, Erlang, Haskell, Clojure, and often comparing a little bit their concurrency models and their communities, everything, right?
00:04:13-00:04:19:  And after I read the book, I had all those options in front of me and Erlang was just shining, right?
00:04:19-00:04:21:  I was like, oh, this is great.
00:04:29-00:04:35:  This is where I want to be building software in the future i that's how i came to it because it was already at the point was uh 2010 it was already at the point where
00:04:35-00:04:40:  i was already having a lot of issues with making rails for example thread safe it was just a pain
00:04:40-00:04:46:  and i knew that uh i want i i knew concurrency was becoming more and more important, right?
00:04:46-00:04:50:  And I didn't want to spend like the next five or 10 years of my life
00:04:50-00:04:53:  trying to fix concurrency issues
00:04:53-00:04:56:  instead of writing the code I want to write.
00:04:56-00:04:59:  So, and then things kind of fit together and you say,
00:04:59-00:05:00:  okay, I want to use that information.
00:05:09-00:05:09:  I started using it more and more and more. And there was some, and I really enjoyed everything,
00:05:12-00:05:14:  but there were some things that I felt for me that are necessary when I'm writing my software.
00:05:14-00:05:18:  Like one of those is a nice way of having metaprogramming.
00:05:18-00:05:22:  The other is having extensibility tools,
00:05:22-00:05:25:  which we have the most important in Elixir,
00:05:25-00:05:34:  I would say they are protocols uh so that's kind of how everything came together and that's exactly how i even uh put the
00:05:34-00:05:39:  goals of the language together later right so if if you like what are the goals of the language we
00:05:39-00:05:50:  say that we have three goals which is compatibility because you want to be compatible with their language machine and the whole ecosystem that's kind of uh the point of the the language and its productivity
00:05:50-00:05:57:  which it can be in many ways right and it's hard for you to to measure productivity in general
00:05:57-00:06:05:  let's just say like uh having a small language core so uh in the in elixir, the language core is very small,
00:06:05-00:06:08:  and we rely a lot on macros to build the language.
00:06:09-00:06:12:  So case, receive, all those things, they are macros.
00:06:12-00:06:16:  And I suspect it's probably the same for List Flavored Airline and Joxa.
00:06:16-00:06:21:  They are just macros, and there's nothing special about them.
00:06:21-00:06:26:  They are implemented with the language constructs, not something special in the parser, in the grammar.
00:06:27-00:06:28:  So it means that
00:06:28-00:06:29:  the language was
00:06:29-00:06:32:  built with most
00:06:32-00:06:34:  of the language constructs, so you can
00:06:34-00:06:36:  get those same constructs and take it
00:06:36-00:06:38:  elsewhere to your domain, for example.
00:06:38-00:06:47:  So you can create domain-specific languages and that makes you more productive, right? So that's our second goal. And the third one is that flexibility have like protocols,
00:06:47-00:06:50:  which is a way for me to write some code
00:06:50-00:06:54:  and you can later extend it with your own data structures,
00:06:55-00:06:56:  with your own types, right?
00:06:57-00:07:00:  Haskell, people call it kind of type classes.
00:07:00-00:07:06:  We protocols, we took them, the naming from Clojure. And yeah, and that's it.
00:07:07-00:07:14:  Sort of the genealogy of the language, then people say, OK, it's Ruby on the Erlang VM.
00:07:14-00:07:20:  And that's, of course, a super gross simplification because it's not just Ruby and it's not just Clojure.
00:07:21-00:07:23:  I mean, there's you've been really out there searching.
00:07:20-00:07:29:  closure i mean there's a you've been uh really out there searching uh yeah so so it's funny because
00:07:29-00:07:35:  that my first attempt and uh at building the language i kind of knew what i wanted to have
00:07:35-00:07:41:  like i knew i wanted to have like metaprogramming and i knew i wanted to have like some kind of
00:07:41-00:07:46:  polymorphies some kind of dynamic, but I didn't know how exactly.
00:07:46-00:07:51:  And that's when I started to search and see things around and how other technologies
00:07:51-00:07:55:  they were solving those problems. And so that's why we have a bunch of stuff from Clojure because
00:07:57-00:08:11:  Clojure is a dynamic language as well. So even for like, Haskell called them like type classes and Solange calls them this. But I went with the Clojure naming because it's closer to what we have and what we want to implement.
00:08:12-00:08:17:  And I would say that those languages that are set are the main influences.
00:08:17-00:08:22:  Ruby, Clojure, and Erlang.
00:08:24-00:08:26:  And I think it resembles,
00:08:27-00:08:29:  and people say it's like Ruby and virtual machine,
00:08:29-00:08:31:  but that's because a lot of the syntax
00:08:31-00:08:34:  and that's what makes people think a lot that,
00:08:35-00:08:37:  but it's mostly the syntax.
00:08:38-00:08:41:  A lot of the semantics, they are, you know,
00:08:41-00:08:42:  it's Erlang virtual machine
00:08:42-00:08:48:  and a bunch of the mechanisms we have uh and the names we use
00:08:48-00:08:55:  we we get a lot from from closure and it's really in a lot of places so we have protocols
00:08:55-00:09:01:  we have the the way our so on the next thing about protocols i'm talking about protocols right so
00:09:01-00:09:11:  what are like the benefits of protocols some of the benefits is that we have an in-num module that knows how to enumerate over a bunch of data structures,
00:09:11-00:09:15:  right? So if you want to map a dictionary, you use the in-num module. You want to map a list,
00:09:26-00:09:28:  you use the in-num module. So it's very nice because you don't need to know about 10 different APIs, one for each data structure. You have one API, one module that you can use to work with many of them,
00:09:28-00:09:31:  and you can plug any data structure you want
00:09:31-00:09:33:  as long as it implements a protocol.
00:09:33-00:09:37:  And even the implementation of the protocol in this case,
00:09:37-00:09:39:  it's very similar to the Clojure one.
00:09:39-00:09:43:  So we really got a bunch of stuff from that side too.
00:09:40-00:09:43:  got a bunch of stuff from that side too.
00:09:44-00:09:48:  I have a question off of that thread to throw at Robert.
00:09:49-00:09:54:  So I've watched Robert for years on the question of syntax and semantics.
00:09:54-00:10:00:  On Twitter, he has to jump in over and over because people say they get this confused.
00:10:00-00:10:04:  So could you talk to us just a bit about language syntax and language semantics?
00:10:04-00:10:06:  Can we get our little Cliff's notes?
00:10:08-00:10:10:  Well, how do you mean?
00:10:10-00:10:14:  I mean, yeah, I mean, syntax and semantics are very different.
00:10:14-00:10:18:  Normally you've had to do it in 140 characters, and so you get more than that now.
00:10:18-00:10:19:  Yeah, okay.
00:10:19-00:10:20:  Okay, yeah.
00:10:27-00:10:29:  No, so my view, well, syntax and semantics are very different. I mean, syntax, what it looks like, semantics, what it means.
00:10:34-00:10:34:  I generally don't have trouble with syntax, so I don't have that problem.
00:10:37-00:10:38:  So if I'm learning a new language, the problem is not the syntax.
00:10:39-00:10:49:  That I find easy. The problem, of course, is the semantics, what it all means, right? So that's sort of my view on, say, running languages on top of another
00:10:49-00:10:50:  machine, a virtual machine.
00:10:53-00:10:56:  You would do it for the semantics, or if you could add something new,
00:10:56-00:10:58:  which is not in the existing language.
00:11:00-00:11:01:  That's my view on that.
00:11:02-00:11:04:  I tend to get worked up when people talk about syntax,
00:11:06-00:11:07:  because I don't see a syntax problem.
00:11:07-00:11:10:  Yeah.
00:11:18-00:11:26:  It's a lot of the sort of bottles that have been thrown, and it seems like such a goofy thing, but it seems to have bothered a lot of folks. It's interesting just the role with Elixir, I think, where the people that had grumbled about that side of it
00:11:26-00:11:27:  and they couldn't get past it,
00:11:27-00:11:29:  they seem to be embracing the language in a funny way,
00:11:29-00:11:32:  which is great on a side,
00:11:32-00:11:35:  and it makes you wonder, was it really that important?
00:11:36-00:11:38:  Well, that's what I mean.
00:11:38-00:11:38:  I don't think so.
00:11:48-00:11:51:  So from my point of Elixir syntax, I don't see it solving a problem, so I don't see the problem. But then again, I think it does manage to has introduced a few features which are quite nice. For example,
00:11:52-00:11:56:  it has improved macros enormously over the standard
00:11:56-00:12:00:  ALANG syntax. It has a much better macro package. It has a macro package
00:12:00-00:12:08:  you actually use to do things, right? And so what I find more their type of things I'm interested in Elixir and also a number of new
00:12:08-00:12:11:  features or things that's introduced which Alan doesn't have
00:12:11-00:12:16:  like the protocols which Jose mentioned. That I find
00:12:16-00:12:25:  is interesting. So from the syntax point of view, I don't see the point. From the other features it introduces, that's where I think the interesting bit is.
00:12:31-00:12:37:  I have a question about that, and I think anybody can chime in, but I always had the impression that Erlang having a foreign syntax kind of helps forget all the preconception
00:12:37-00:12:46:  of the baggage you had so that you can just jump into language from a fresh point of view so that you don't get bugged up on semantics
00:12:46-00:12:48:  from other languages you knew before.
00:12:49-00:12:50:  That was my experience.
00:12:51-00:12:57:  And this is something that I'm wondering about in Elixir because it looks a lot more like Ruby
00:12:57-00:13:01:  or any kind of other language that people have used before that are not Prolog or Erlang.
00:13:06-00:13:06:  And I asked myself the question,
00:13:08-00:13:10:  is it faster to get started with it because you're familiar, but then
00:13:10-00:13:12:  once you're up to speed or almost up to
00:13:12-00:13:14:  speed, do you get to run into more walls
00:13:14-00:13:16:  as the expectations you carried over
00:13:16-00:13:18:  from different platforms or languages
00:13:18-00:13:20:  start slowing you down into
00:13:20-00:13:22:  the semantics themselves?
00:13:25-00:13:31:  So I actually wonder about that as well, Jose. Like Elixir has somewhat similar-ish syntax to, say, Ruby, right?
00:13:31-00:13:33:  But the semantics are completely different.
00:13:34-00:13:38:  And I know being on the Elixir mailing list and watching on IRC
00:13:38-00:13:41:  and this kind of thing, there's this point where people come
00:13:41-00:13:49:  into the language, right their with their um with their ruby background or their maybe their python background or what have you with a certain set of
00:13:49-00:13:54:  expectations and you know and for the first five minutes those expectations might hold but then
00:13:54-00:13:59:  very very quickly get to get into this point where where their expectations of what things should be
00:13:59-00:14:06:  and what things actually are are completely different yes and they have to run through this kind of mismatch between reality and their
00:14:06-00:14:07:  internal worldview.
00:14:09-00:14:12:  I've had a few conversations with people who
00:14:12-00:14:14:  got into just that, and the story
00:14:14-00:14:15:  had a happier ending than you might expect.
00:14:16-00:14:18:  They did have that
00:14:18-00:14:20:  mismatch, and it was painful for a bit.
00:14:20-00:14:25:  But then they found that the real problem wasn't the mismatch with Elixir. It was returning to Ruby.
00:14:26-00:14:31:  So they were – we lured them to the dark side.
00:14:35-00:14:36:  Happened, Joe.
00:14:36-00:14:39:  Yeah, no, I think the problem is slightly different.
00:14:40-00:14:42:  I agree with Robert about syntax.
00:14:43-00:14:46:  There seem to be a couple of phases in doing things.
00:14:46-00:14:48:  The first phase when you learn programming languages
00:14:48-00:14:51:  is just getting the commas and brackets in the right places.
00:14:52-00:14:55:  And that goes over very soon, I think.
00:14:55-00:14:56:  I mean, that just gets into your spine.
00:14:56-00:14:58:  And it's something I forget all the time.
00:14:58-00:15:05:  I nip backwards before airlang and JavaScript and C and all sorts of things.
00:15:08-00:15:08:  And in fact, when I just flip between languages very quickly,
00:15:11-00:15:14:  I find myself putting semicolons at the end of lines of Erlang and doing things like, oh, no, silly me, it's in Erlang.
00:15:14-00:15:15:  It's a comma there.
00:15:15-00:15:19:  That goes over very quickly, and you internalize it.
00:15:30-00:15:31:  I think then there are things that you think are going to be problems that aren't. OK, so in Erlang, everybody said, well, this notion of single assignment variables is going to be a problem.
00:15:38-00:15:38:  But in practice, it isn't, because what you've told people, if you've got x equals one, you can't say x plus one.
00:15:40-00:15:40:  OK, so what do you do?
00:15:42-00:15:46:  We just introduce new variables. So X1 is X plus 1. No problem. They get that, and it's not a problem.
00:15:46-00:15:49:  And then recursion, it's sort of they've heard the word,
00:15:49-00:15:51:  and they think, oh, recursion is going to be a problem.
00:15:51-00:15:54:  But say, okay, look, just write it like this, and it'll work.
00:16:09-00:16:14:  It works, and they don't their programs because if they're used to to doing object-oriented programming they're used to breaking down the problem into objects so that they're looking at and saying well what do i do where are the objects if you're building things in airline you've got to look at the concurrency
00:16:14-00:16:29:  structure you've got to say where are the processes but they're not used to processes you see they don't know what processes are and that's where the problem's come it's not the functional bit it's not the variables of single assignment bindings it's a concurrency that's a problem and it's a failure model that's a problem that's that's
00:16:29-00:16:36:  because that's completely different so there was a very good um thread on the airline mailing list
00:16:36-00:16:45:  of a and it was called something like i can't remember it was about it was about sort of how do i write a model view controller in airline for a game right and somebody
00:16:45-00:16:51:  had come from i don't know ruby or python or php or something but he'd come from a single threaded
00:16:51-00:16:57:  language and he's writing a multi-user game so how do you write a multi-user game in a single
00:16:57-00:17:07:  threaded language well each person in the game has state so what you do is you you when one person is active you retrieve the state from a database
00:17:07-00:17:11:  you perform a computation and then you put it back in the database and then you go and look
00:17:11-00:17:15:  at the next thing so you're emulating the concurrency yourself so when he wanted to write
00:17:15-00:17:25:  a game in airline the first thing he did is that well i need to interface airline to a database because that's what i'm going to store the state in and so he got himself a database and
00:17:25-00:17:29:  he wrote this and he wrote everything in one thread more or less putting it into the database
00:17:29-00:17:34:  just like he'd always done in all other languages he'd ever seen and then he asked a question on
00:17:34-00:17:49:  the yelling list and the guy said excuse me you don't need to put the state in the database because each process can remember its own state because they're non-blocking because you've got the concurrency you design it in a completely different way and that's what the problem is it's not the commerce it's not the
00:17:49-00:17:54:  syntax it's not the recursion it's not the it's this way of breaking down things into parallel
00:17:54-00:18:08:  processes and sort of designing the algorithm so so that they can each work on their own private data sets that's what the problem is but the benefit is going to come when they distribute that over a multi-core or something like that because they've done all this work that enables the
00:18:08-00:18:12:  parallelism and enables the fault tolerance and enables the scalability they don't have to go
00:18:12-00:18:27:  and do that later because they've already done it and that's that's that's why allen in a sense is much more difficult to learn than all these other languages because it new way of thinking. Yeah, it's a rethink. What I find interesting, the method Joe described, which is common today,
00:18:27-00:18:31:  that's exactly the same thing that the AXC, the Ericsson switch,
00:18:31-00:18:35:  the AXC switch from the late 70s, that's how it was programmed.
00:18:35-00:18:38:  So I just find it ironic.
00:18:45-00:18:52:  As a technology, it's a very old way of modeling the system um and again as joe mentioned that having process means i don't have to do that each process can i can model that as a separate entity um processing its input doing what needs
00:18:52-00:18:55:  needs to do and things like this without having to worry about any other processes in the system
00:18:55-00:19:07:  and it's a complete it's a complete rethink of how you design systems so i think when when people start programming aia, they're probably – the big mistake that everybody makes in Erlang is not using enough processes.
00:19:07-00:19:13:  And I suspect in Alexia it will be exactly the same, that they will tend to write sequential code instead of using lots of processes.
00:19:15-00:19:15:  Yeah.
00:19:15-00:19:23:  So far, Jose, what have you seen there from the people from the Ruby, the Rails – from that side?
00:19:25-00:19:26:  What have you seen, the Rails, from that side, what have you seen the things that they've bumped into?
00:19:30-00:19:31:  You have definitely a better tap into that community than any of us.
00:19:32-00:19:33:  Yeah, that's a tricky question.
00:19:37-00:19:45:  I'm not sure how exactly what I have seen. I guess I'm too much inside, but there is.
00:19:46-00:19:49:  So based on this discussion, what we were saying,
00:19:49-00:19:52:  there are a lot of people coming from Ruby,
00:19:53-00:19:58:  and they are looking at it, they are trying to solve,
00:19:58-00:20:02:  or they are actually evaluating at this point,
00:20:02-00:20:04:  like mostly they are still evaluating the language,
00:20:04-00:20:05:  and they
00:20:05-00:20:11:  would say like, well, I want to use this thing to build the same things I built today. So they are
00:20:11-00:20:18:  looking, they're going after the same tools, right? Very similar tools. So where is my MVC framework
00:20:18-00:20:32:  and where is the tool that does this that I'm used to? And it's a good point for us to do some kind of teaching, right?
00:20:32-00:20:38:  Like, no, look, here you're going to build this thing differently, right?
00:20:38-00:20:41:  It's like you need to come with a whole other approach.
00:20:41-00:20:48:  But at some other point, you say, well, this looks like a very good short-term trade-off,
00:20:48-00:20:54:  and they end up building this particular trade-off or something more similar to what they have today.
00:20:57-00:21:09:  I guess there is this idea that you're going away from a given way of doing things to change whatever property of the system might be speed or scalability,
00:21:09-00:21:14:  and you're trying to use the same exact design you had before, just in a different language.
00:21:14-00:21:19:  So what do you really expect to go differently if the system is the same, just implemented in a different platform?
00:21:19-00:21:20:  That's what's wrong.
00:21:21-00:21:26:  Imagine you're going to do something like Twitter or a messaging system. If you start off in a conventional language, you're going to say,
00:21:26-00:21:30:  okay, so you'll dimension the number of users per machine,
00:21:31-00:21:32:  something like that, and you'll have to sort of scale them out
00:21:32-00:21:34:  or distribute them to particular machines.
00:21:34-00:21:51:  And then you say, okay goddamn awful locking and scheduling thing
00:21:51-00:21:55:  and then you'll put all the hundred thousand users in the database and then when they're active
00:21:55-00:22:06:  you quickly nip out of the database and do whatever you're going to do or schedule it onto one of the threads, and when they've done it, stick it back in the database. And your concerns will be getting things in and out of the database very quickly.
00:22:07-00:22:08:  But if you do it in Erlang, you can say,
00:22:08-00:22:09:  okay, we'd imagine it for 100,000 users.
00:22:10-00:22:12:  So start off, we have 100,000 parallel processes.
00:22:13-00:22:15:  Right. There's no database.
00:22:27-00:22:27:  You Let me step back a little bit from Erlang and Elixir. I talked with Neil Ford at OSCON. He gave a talk, and it was aimed at Java folks,
00:22:31-00:22:32:  so people using the JVM and functional languages that run over there.
00:22:45-00:22:48:  And his talk was really just the first steps towards getting people out of that orthodox OOP model. And that's a much bigger conversation than choosing between Erlang and Elixir. It's the conversation we need to get going broadly.
00:22:48-00:22:50:  I'm hoping to get more of it at OSCON.
00:22:52-00:23:04:  But my hope – and actually I guess what I'm actually seeing people doing with Elixir is they're finding themselves having to get involved in that conversation and suddenly having to pay attention to things that they'd heard about.
00:23:05-00:23:07:  They'd heard about. They'd heard about processes. They sound cool, but how do I do that?
00:23:09-00:23:12:  Yeah, that's a very good point,
00:23:12-00:23:16:  and it's a point that when I have those discussions, I make it frequently.
00:23:16-00:23:18:  So we're talking about syntax, right?
00:23:19-00:23:22:  And some people, they feel like the syntax,
00:23:26-00:23:27:  maybe Erlang syntax is blocking them. And we were talking about syntax and semantics.
00:23:31-00:23:31:  But everyone that comes to Elixir, if they stay with Elixir,
00:23:32-00:23:32:  they don't stay because of the syntax.
00:23:34-00:23:34:  They stay because of the semantics, right?
00:23:39-00:23:46:  Nobody say, oh, I love Elixir because the syntax is so great, right? They may say it like in the first two hours but when you go back after one week they're seeing oh like those processes
00:23:46-00:23:51:  actors message passing and they're excited about this and that's why they stay that's why they
00:23:51-00:23:57:  want to explore further the syntax is like the steak that you throw to the dog while you rob the
00:23:57-00:24:08:  house yeah and it's the same for everything else. Even when I'm saying people,
00:24:08-00:24:09:  they are building similar tools,
00:24:09-00:24:13:  but when they are creating even a simple project in Elixir,
00:24:13-00:24:16:  and it's something that I wanted since the day one,
00:24:16-00:24:18:  I wanted to make very simple to have in language.
00:24:18-00:24:20:  We have a library that ships with
00:24:20-00:24:25:  Elixir that allows you to create new projects. And you already created an application,
00:24:29-00:24:29:  and it already comes with a supervisor and a server.
00:24:31-00:24:31:  But even if you don't use it, those things,
00:24:36-00:24:38:  we are putting time by time a little bit in your head that there is this application thing, right?
00:24:38-00:24:40:  There's a supervisor thing.
00:24:48-00:24:49:  And then slowly they get used more and more with those things, right? And then they start to worry more about it and how they can use it.
00:24:58-00:25:02:  Because otherwise, if we want them to jump from like building applications in completely different way, it's just too big of a jump, right? People will be scared to do it, right?
00:25:02-00:25:04:  Because it's just too much of a radical change.
00:25:00-00:25:06:  scared to do it right because it's just too much of a radical change and a lot of people can do
00:25:06-00:25:13:  that but it usually requires a lot of vision for you to go from point a to point b and say wait
00:25:13-00:25:19:  when it's there in the future in point b i know it's going to be better than what i have today
00:25:19-00:25:26:  it requires a lot of vision and people sometimes they they don't feel comfortable with doing such huge job.
00:25:27-00:25:30:  The other thing, comment I have about Elixir,
00:25:31-00:25:32:  which I like very, very much,
00:25:32-00:25:36:  is the way you're going about it
00:25:36-00:25:38:  and the way the language is being designed.
00:25:39-00:25:41:  I'd have to expand upon that a bit.
00:25:41-00:25:43:  I think it's absolutely fantastic
00:25:43-00:25:50:  that you co-develop the language with the writing of the books that are virtually coming out at the same time. And that I think is
00:25:50-00:25:54:  totally fantastic. And as a book author, I'm astounded to see a community that listens to
00:25:54-00:26:25:  the book authors. It makes me very happy. So if you look at, and this has happened because of a technological change. I think Alexia must be one of the first languages that's developed sort of on the Internet so that Jose can hold a dialogue with lots of other people. If you compare Erlang with Alexia and how it's developed, the conversations that Jose is having in the newsgroups and things with a lot of talented people. That's a kind of equivalent to the conversations
00:26:25-00:26:30:  that Robert and I were having, you know, in 1985, 1986. But the difference is, I mean,
00:26:31-00:26:38:  we didn't have the benefit of a wider community to discuss those ideas with. So Robert and I would
00:26:38-00:26:43:  spend all day or many hours each day talking about the semantics of Erling and what it should be.
00:26:45-00:26:48:  But there was only the two of us doing it, and that was for technical reasons. We couldn't go in to sort of tap into the knowledge
00:26:48-00:26:50:  of loads of other people who were interested.
00:26:50-00:26:54:  And when Ruby was developed, it was done in one guy's head,
00:26:54-00:27:05:  and Python and Perl and C and all those things were developed in very here is being developed with the new versions coming out on the net and with a lot of interested
00:27:05-00:27:10:  people being able to contribute to that conversation and and jose's been a fantastic
00:27:10-00:27:15:  job i think you know i've thrown a few ideas at him on in various mails and things and he's he's
00:27:15-00:27:25:  more in the role of being able to ask people for help and to try out ideas and to act as a sort of throwing balls at him and he's batting them away and saying, well, that's a good idea and that's a bad idea.
00:27:29-00:27:30:  Because, you see, language idea isn't really about it's not really right or wrong.
00:27:34-00:27:35:  It's about a set of design decisions that you make that sort of hang together.
00:27:39-00:27:45:  You know, I mean, you can is good for that sort of application.
00:27:46-00:27:46:  That's what yours is doing.
00:27:48-00:27:48:  He's choosing between these different things.
00:27:49-00:27:50:  I think he's doing an excellent job.
00:28:06-00:28:07:  Then you've got Dave and Simon writing books at the same time. And that is utterly fantastic because I've always thought, you know, I hate reading code and programs and things to find out what it's supposed to do. I want to read a book that tells me how it should work.
00:28:11-00:28:11:  And now you've got a book, and it's about a year after the development.
00:28:26-00:28:26:  That will influence the language development in a way I haven't seen before. Because what happens there is if the authors cannot describe the feature of the language, if they try really hard and say, however we try to describe this, it just doesn't come out right.
00:28:28-00:28:28:  You know, we can't describe it.
00:28:30-00:28:31:  Then you should bloody well remove it from the language.
00:28:35-00:28:36:  You know, because the stuff that you find difficult to explain to people will always be there.
00:28:45-00:28:49:  If you can't find an easy way to explain it now five to 10 years time. And you'll spend the rest of your life trying to explain it to people. So if Dave and Simon can't explain it, remove it from your language.
00:28:49-00:28:51:  OK, and that's absolutely great.
00:28:52-00:28:55:  So if you look at the airline case, it was I wrote in this blog thing.
00:29:05-00:29:06:  It was it was actually seven years afterlang was developed and the first popular book came out.
00:29:08-00:29:08:  And you've got that down to about a year.
00:29:13-00:29:13:  And that and the way it's designed is one of the first languages where that's happened.
00:29:15-00:29:16:  So it's extremely interesting to see what happens.
00:29:32-00:29:48:  That process, Jose, so how are you keeping – what is your process as ideas come in, as feedback comes in, to keep the thing beautiful and keep it from being a Frankenstein, like this sort of monster? back and I usually don't try to take immediate action even because I still have quite some time
00:29:48-00:29:59:  before we go to 1.0 so I usually let it in the back of my head and because and and then I try
00:29:59-00:30:08:  to get another information enough information or I wait enough time until some moment that's not specified in any way
00:30:08-00:30:15:  that I think, well, now is the time to change or try to incorporate this feedback from X, Y, and Z
00:30:15-00:30:20:  and try to tell a better story in this particular area of the language.
00:30:20-00:30:23:  So what do you do when Dave says, oh, I can't describe this stuff,
00:30:26-00:30:27:  or you read his text and say, oh, that's awful.
00:30:27-00:30:28:  What do you do then?
00:30:29-00:30:30:  Do you remove it from the language?
00:30:33-00:30:33:  I wait, and it's there.
00:30:34-00:30:46:  I know that I need to act on it. So I have a list of things that I definitely need to check before we get touch uh with dave for example we are exchange ideas on how we can solve
00:30:46-00:30:52:  that but i don't try to act on it right now because maybe i have like two things and there
00:30:52-00:30:58:  is a third thing that's missing but i don't know what is what it is yet so i'm just waiting with
00:30:58-00:31:07:  the hope that this third thing is going to appear and then i can change this thing that's going to make Dave happy. It's going to make me happier and it's going to make everyone happier.
00:31:08-00:31:11:  So it's usually a mental log.
00:31:12-00:31:13:  Yeah. And I'm happy to say it hasn't been,
00:31:13-00:31:16:  mostly we've asked you for like small additions.
00:31:16-00:31:18:  There was one thing to do with parentheses.
00:31:19-00:31:21:  It really hasn't been that dramatic.
00:31:25-00:31:26:  There's an interesting question.
00:31:27-00:31:27:  Go ahead, Joe.
00:31:30-00:31:31:  I was just asking, Jose, if you'd put in the...
00:31:31-00:31:34:  It was in my blog. I said you can't
00:31:34-00:31:36:  put... When you're defining functions
00:31:36-00:31:38:  in modules and trying to define, it
00:31:38-00:31:40:  works different to closures that you define
00:31:40-00:31:53:  in the shell. And I wanted the two to be the same because it's going to confuse everybody forever yeah so i mean when i was doing ailing okay so i wrote i wrote the first draft the yelling book
00:31:53-00:32:00:  and dave thomas was my editor and he said um he was kind of surprised because he used to
00:32:00-00:32:05:  to to languages where what you type in the shell is exactly what you put in a file.
00:32:05-00:32:07:  So many languages, things like that, JavaScript,
00:32:08-00:32:10:  whatever you put in a file, you can just pipe into the shell
00:32:10-00:32:11:  and you get exactly the same results.
00:32:11-00:32:12:  And it's not true in Erlang.
00:32:13-00:32:15:  The last time I looked at Alexia, it wasn't true in Alexia.
00:32:30-00:32:30:  And he said, well, why is this It's like that, and we passed over it. But it was wrong. In fact, it's a fault in Erlang's design that what you put in a module, you can't put in a shell.
00:32:31-00:32:32:  It's the same in Alexia.
00:32:39-00:32:46:  There is a question about that where what you can say is either the explanation is not right or the language is not right. Someone on IRC described to me that your lang shell is not really a shell, it's an interactor, the same thing you get in Prolog.
00:32:46-00:32:48:  And there's a running system, and what you can
00:32:48-00:32:50:  do is discuss with it, but it's
00:32:50-00:32:52:  not a redevelopment loop you get
00:32:52-00:32:52:  as usually.
00:32:54-00:32:56:  But if you frame
00:32:56-00:32:56:  things that way,
00:33:06-00:33:08:  I don't think that we had is not really... The most common reaction
00:33:08-00:33:10:  to things in my book and on
00:33:10-00:33:12:  all the mailing lists
00:33:12-00:33:14:  and forever, the most common error people
00:33:14-00:33:16:  make is they see
00:33:16-00:33:18:  some code in a module
00:33:18-00:33:25:  because they're reading modules to figure out how stuff works and they cut and paste into the shell, and it doesn't work. That's the most common error they make. But they don't do it.
00:33:26-00:33:29:  They're not going to make the error more than once or twice, right?
00:33:29-00:33:29:  Oh, they do it.
00:33:30-00:33:30:  Yeah.
00:33:30-00:33:34:  Well, yes, but 100,000 people doing it once or twice is 200,000 queries.
00:33:46-00:33:46:  Yeah, but they do it themselves once It'll be on the site where you post programming problems. It'll be there forever.
00:33:47-00:33:48:  Stack Overflow?
00:33:49-00:33:49:  Yeah, Stack Overflow.
00:33:50-00:33:50:  Why can't I post it?
00:33:52-00:33:53:  Because you can't.
00:33:53-00:33:54:  That's the answer.
00:33:55-00:33:56:  I agree with Joe, absolutely.
00:33:57-00:34:05:  That's not a valid answer. Like 10 years into using or relying, it still annoys me that I can't create a function in the shell.
00:34:06-00:34:07:  The shell is this limited environment.
00:34:08-00:34:10:  Literally almost every time I sit down
00:34:10-00:34:12:  to use the shell, I think to myself,
00:34:12-00:34:13:  why is this so limited?
00:34:15-00:34:16:  That's not
00:34:16-00:34:17:  twice for you then, Eric.
00:34:18-00:34:18:  No, it's not.
00:34:19-00:34:21:  It's three times, right?
00:34:21-00:34:22:  I can't count.
00:34:27-00:34:32:  Just times yeah i can't count i wrote just to say they're different you write functions in the module and you enter expressions in the shell and they're different that's just it that's it i know
00:34:32-00:34:38:  i know robert but yes i know unfortunately i wrote a blog on alexia and i i formulated something
00:34:38-00:34:47:  which i hadn't thought of before but i said it was called the three laws of programming Programming Language Design, which I've got in front of me, and I rather like what I wrote, because he said, what you get right, nobody, you know,
00:34:47-00:34:49:  if you get something right, well, nobody will ever mention it, okay?
00:34:49-00:34:50:  Nobody will mention it.
00:34:51-00:34:54:  So concurrency in the link mechanism, the error handling in Erlang, is right,
00:35:10-00:35:17:  and got string well i'll say we got strings wrong but it was so we didn't no okay it was misunderstood a lot okay the stuff that is difficult to understand you will have to explain to people over and over and over again okay so i just have to ask you know authors of books and designers
00:35:17-00:35:26:  do you want to spend the rest of your life explaining over and over and over and over again why it behaves as it does? Or do you want to change it so that you won't have to explain it
00:35:26-00:35:27:  over and over again?
00:35:28-00:35:28:  It's a design decision.
00:35:29-00:35:30:  You can design the shell
00:35:30-00:35:32:  so that you can't cut and paste stuff.
00:35:33-00:35:36:  The other solution is just to get popular enough
00:35:36-00:35:48:  that people expect the thing you did to be the standard Everyone else has to create whatever they're doing. Yeah. The trouble in Erlang is that, okay, you could – well, you can.
00:35:49-00:35:52:  I mean, Lexis does define modules in the shell.
00:35:53-00:36:04:  But you can't sort of define functions because, I mean, the way the code is handled in Erlang is that functions are part of a module.
00:36:04-00:36:07:  And the whole unit of working is with the module.
00:36:07-00:36:08:  Right.
00:36:08-00:36:11:  But all that needs is an open...
00:36:11-00:36:13:  I mean, we've got a thing that opens a module.
00:36:13-00:36:16:  All you need in the shell will be a closed module statement.
00:36:16-00:36:17:  Then they will be the same.
00:36:26-00:36:26:  Yeah, but then you're still not doing it... When you define things in a shell, you don't know which module they're in. But you could define a sort of pseudo module called shell.
00:36:30-00:36:30:  And if you define a fun in there, it's actually a function inside a module called shell or something, whatever.
00:36:31-00:36:31:  That's exactly it.
00:36:48-00:36:50:  You just need some way to set kind of the current module on the shell and Adding a couple of extra functions to manipulate the current module is not that difficult, right?
00:36:52-00:36:53:  So that was wrong enough.
00:36:53-00:36:57:  Well, actually, I'll be different here.
00:36:57-00:37:02:  I actually prefer writing my functions in a module because then I've got
00:37:02-00:37:06:  the full power of the editor I'm using, Emacs, to do all this stuff, right? If I'm
00:37:06-00:37:07:  entering it in the shell,
00:37:08-00:37:10:  the actual code I write is going to
00:37:10-00:37:11:  look pretty
00:37:11-00:37:14:  raw
00:37:14-00:37:16:  compared to what I do in the
00:37:16-00:37:28:  I mean, I think it's the other way around. I think the problem. Because if you could, you could do partial evaluation. Well, I use LFE and have a macro package.
00:37:30-00:37:32:  That's the way you do it in a real language.
00:37:32-00:37:34:  Same for me and Jocksa.
00:37:34-00:37:46:  But Robert, I write code the exact same way you do. I spend 95% of my time in Emacs writing code, whether it be Elixir or Erlang, and letting Emacs interact on the back end for me.
00:37:46-00:37:53:  But there's some not insignificant amount of time when I'm testing things out in the shell that I'm not completely sure are going to work.
00:37:53-00:38:00:  So I'm writing func or I'm not writing in Lisp or Python or Ruby or something with a full featured interactive REPL.
00:38:07-00:38:08:  I I'm doing that, right? In Erlang, I don't. Well, I don't either. So I write everything in Emacs and I type make.
00:38:13-00:38:16:  So the thing is that in order to make it work, I think both Erlang and Elixir,
00:38:17-00:38:20:  we are going to break user expectations at some point.
00:38:20-00:38:22:  I don't think the way things are today,
00:38:26-00:38:34:  we can not break I don't think the way things are today, we cannot break user expectations. For example, let's take AirLake. I think that if we allowed people to, if we could have this idea of an open module in the shell,
00:38:35-00:38:44:  there is something that the user will try to use, like, let's say, code parse transform, right?
00:38:48-00:38:48:  That's not going to work because you don't have the whole module, right?
00:38:52-00:38:53:  So if we try to make something like this,
00:38:55-00:38:55:  at some point, it's going to break the expectation.
00:38:57-00:39:00:  At some point, it's going to leak that it's a hack around with a module half open.
00:39:00-00:39:06:  And in Elixir, I think it would be easier because, for example, we have something called before compile, which is a callback
00:39:06-00:39:08:  that we execute before
00:39:08-00:39:10:  the module is being
00:39:10-00:39:11:  compiled, which
00:39:11-00:39:14:  allows you to do things that you would be able to do
00:39:14-00:39:16:  with a parse transform. And then
00:39:16-00:39:18:  if people think that they are really inside a module,
00:39:18-00:39:29:  but since this module is never closed, There's some functionality that I use that depends on this before compile, but it's never actually compiled because it never closes, right? And then what they are going to
00:39:29-00:39:34:  have is that they're going to have an issue that's much harder to track down and much harder to
00:39:34-00:39:48:  understand. So that's kind of my perspective why I didn't allow you to define functions outside of a module in the shell, because at some point, in some way, that expectation is going to break,
00:39:48-00:39:50:  and it's going to bite you.
00:39:51-00:39:53:  Yeah, I mean, they're going to write code,
00:39:53-00:39:57:  which then calls back the shell, which, again, calls the shell module.
00:39:59-00:40:02:  If you're writing it, that'd be natural to do that.
00:40:06-00:40:08:  Or you want to pass the shell modules as a callback module to something.
00:40:08-00:40:10:  And if you haven't defined
00:40:10-00:40:12:  the whole module in one sense, it doesn't really exist.
00:40:13-00:40:15:  So don't do it that way, right?
00:40:16-00:40:28:  Compile the module every time you have it. Recompile the module and reload it every time you change it, make it a real first-class module. Yeah, but the trouble with that is that reloading affects the runtime system.
00:40:28-00:40:32:  So if you've got a number of processors running there and you reload the thing,
00:40:32-00:40:34:  then you suddenly start killing processors.
00:40:35-00:40:36:  But really, what you want to –
00:40:36-00:40:40:  My question is that none of them – it might be a decent solution,
00:40:46-00:40:48:  but you're going to get confusion somewhere. But really what you want is some introspection facilities. I mean, in Erlang, it doesn't
00:40:48-00:40:50:  have module. You really want, say, module
00:40:50-00:40:51:  to list of funds,
00:40:51-00:40:54:  and then you want list of funds to module
00:40:54-00:40:56:  and things like that, so you can introspect
00:40:56-00:40:58:  and sort of
00:40:58-00:41:05:  you can't Lisp, you take something out and you add a wrapper for debugging,
00:41:05-00:41:06:  you put it back in again,
00:41:06-00:41:09:  and you can't do that sort of metaprogramming.
00:41:09-00:41:11:  You could do it fairly easily,
00:41:11-00:41:14:  given that you have access to a compiler interlying,
00:41:14-00:41:26:  except for the entire point where you could be trying to and then the environment just doesn't work the same anymore and that you get that problem.
00:41:26-00:41:28:  Yeah.
00:41:29-00:41:30:  Yeah.
00:41:31-00:41:31:  Yeah, I don't know.
00:41:33-00:41:33:  As I say, I'm used to it now,
00:41:35-00:41:36:  so this is how I think with interacting with systems.
00:41:39-00:41:39:  So I don't see it as a problem.
00:41:40-00:41:41:  No, I just think it's a problem.
00:41:46-00:41:48:  Yeah, I know I know people see that the Allang shell does not act
00:41:48-00:41:50:  in the same way other shells do
00:41:50-00:41:52:  No, it's not like that
00:41:52-00:41:53:  I would like to do in module 40
00:41:53-00:41:56:  I can't say
00:41:56-00:41:58:  x is outside
00:41:58-00:42:00:  the function definition, I can't say x is
00:42:00-00:42:02:  3 times 4 and then just use
00:42:02-00:42:06:  the x inside the next function definition, which is a pretty reasonable thing to do.
00:42:06-00:42:07:  Which you can do in the shell.
00:42:07-00:42:09:  The question is, when's that going to be done?
00:42:09-00:42:10:  At compile time.
00:42:11-00:42:12:  At compile time, okay, yeah.
00:42:12-00:42:13:  Then you could do it.
00:42:28-00:42:29:  I mean, I've got a very go away. I will freely admit that the Erlang macro package is a big hack.
00:42:32-00:42:33:  On macros, this is a good segue.
00:42:39-00:42:49:  Macros in Erlang, you know, we can have like our question mark module and we can do all the stuff that we do inside of E-unit. How does, with Elixir, how has that been extended? Can you tell us a bit
00:42:49-00:42:55:  about how, where it goes beyond what we're used to? So we're all Erlang developers listening to
00:42:55-00:43:02:  this. Tell us what all Elixir gives us. Okay. So there, we have two main things.
00:43:00-00:43:02:  So we have two main things.
00:43:04-00:43:07:  One of them is that you actually,
00:43:08-00:43:10:  so early macro is kind of substitution, right?
00:43:11-00:43:13:  What you have on the side is substituted
00:43:13-00:43:16:  as is where you're calling that,
00:43:16-00:43:18:  when you're calling that macro.
00:43:18-00:43:22:  And in Elixir, the macro is actually a code
00:43:22-00:43:24:  that you run, a code that you write,
00:43:26-00:43:26:  and we run it for you at compilation time.
00:43:32-00:43:33:  And you receive as argument the structure of the code you pass as argument to the macro,
00:43:33-00:43:35:  the representation of that code.
00:43:36-00:43:40:  So what we can do with this, for example,
00:43:40-00:43:44:  is that we have if, which is like traditional language,
00:43:44-00:43:47:  if it's implemented as a macro as an
00:43:47-00:43:54:  elixir macro and it simply transforms everything to a case right so we can we can receive the code
00:43:54-00:44:00:  and you can transform it in different ways and uh that's how our macros work so that's one thing
00:44:00-00:44:08:  and the second thing it's hygiene if for example in an Erlang macro, you define a variable or you have a case.
00:44:08-00:44:12:  For example, you have a case in the macro, and that case defines a variable.
00:44:13-00:44:20:  If you use that macro two times, you're going to start getting a match because the variable is exactly the same.
00:44:20-00:44:26:  In our case, we have hygiene that allows both for you to use the same macro at different
00:44:26-00:44:32:  times and the variables are not going to clobber. And since macros cannot generate a bunch of
00:44:32-00:44:37:  variables, we don't want those variables to conflict with your variables, right? So if the
00:44:37-00:44:50:  macro defines that x is equal one and you have your own x in your code, you don't want your X to be overwritten. So I think those are the main two things we bring to the table. This process of where you're doing the transfer. So the code
00:44:50-00:44:54:  that you're getting, is this, are we talking about the level of it becoming like core Erlang at this
00:44:54-00:45:15:  point or like Erlang assembly, or are we talking about this is still Elixir that you're having and Yeah, great question. It's two Alexers. So we have the kind of the Alexia abstract format, right, which just states our coded expressions. And that's what you get. And the representation, we try to be as straightforward as possible.
00:45:20-00:45:21:  more regular than Ruby.
00:45:22-00:45:25:  And that's because we need to map code
00:45:25-00:45:27:  to its internal representation.
00:45:28-00:45:29:  And the way Lisp does that
00:45:29-00:45:32:  is that what you see is like what you get, right?
00:45:32-00:45:33:  There are lists here, there is there.
00:45:33-00:45:35:  I didn't want to have a list
00:45:35-00:45:37:  because we already have Joxa, Awafi.
00:45:38-00:45:47:  So I wanted to have a language that the translation from one place to the other was as straightforward as possible, right? So otherwise it gets too hard to use the macro system.
00:45:47-00:45:48:  No, it's beautiful.
00:45:49-00:45:50:  Thank you.
00:45:50-00:45:56:  So would you define it as kind of in between a Lisp in terms of macros and the Erlang parse transforms,
00:45:56-00:46:03:  which do operate pretty much the way you meant it, but the abstract representation is fairly ugly, I guess.
00:46:06-00:46:07:  There were two things. I mean, we could have actually done it in this,
00:46:07-00:46:07:  in Erlang,
00:46:08-00:46:08:  if it's a fact,
00:46:09-00:46:10:  we could retro-engineer it back into Erlang.
00:46:11-00:46:11:  I mean,
00:46:14-00:46:17:  the thing about writing parse transforms in Erlang is you have to know what the parse tree of concrete Erlang is,
00:46:26-00:46:27:  and because you don't want to know what it is at all. But just introducing a quasi-quote and the splice mechanism,
00:46:29-00:46:29:  which Lisp has, frees you from all that.
00:46:31-00:46:31:  You don't need to know what the underlying syntax is,
00:46:32-00:46:32:  and that makes it really easy.
00:46:46-00:46:54:  The other thing is you can do, I mean, the one, you know, like cooking, you know, these celebrity chefs have their signature recipes well i think the alexia signature program should be the macro package that figured out a function to compute mime types of different file extensions
00:46:54-00:47:01:  because there's just a i don't know 20 lines of code and it goes and fetches it goes and fetches
00:47:01-00:47:06:  a big data file from from some website that's got a description of all the MIME types,
00:47:06-00:47:09:  then it transforms that into an Exia and compiles it.
00:47:09-00:47:11:  It's about 10 lines of code or something.
00:47:11-00:47:13:  Absolutely wonderful and beautiful.
00:47:14-00:47:19:  I suppose we could steal that macro idea and fit it into ALANG, actually.
00:47:19-00:47:20:  We could steal it and stick it into ALANG.
00:47:33-00:47:35:  Yeah, definitely. In Erlang, we could equally represent the Erlang terms with a much simpler representation, too, and have a quote.
00:47:43-00:47:44:  A feature mentioned earlier, the pipe forward, it's leveraging this metaprogramming bit here to do this, right?
00:47:45-00:47:45:  Sorry, which feature?
00:47:46-00:47:48:  The pipe forward.
00:47:51-00:47:52:  Yeah, so the pipe forward is,
00:47:54-00:47:55:  so in other functional languages,
00:47:56-00:47:57:  they implement that with current, for example,
00:47:58-00:47:58:  zone place for it to implement it.
00:48:00-00:48:01:  We don't have that in Elixir because we need the RET.
00:48:05-00:48:07:  So what we do is that we just translate. So the pipe forward is an operator.
00:48:08-00:48:12:  An operator for Elixir is just a function call as any other thing
00:48:12-00:48:14:  and can either be a function call or a macro call.
00:48:14-00:48:16:  And in this case, it's a macro.
00:48:16-00:48:18:  So it's a macro that receives two arguments,
00:48:18-00:48:21:  and we just transform it to be something else.
00:48:26-00:48:28:  And it's like the very raw implementation for this would be like eight lines of code.
00:48:28-00:48:30:  And then if you want to add some nice
00:48:30-00:48:32:  messages, check some proper
00:48:32-00:48:34:  cases, it gets, I would say
00:48:34-00:48:35:  like 15 lines of code.
00:48:36-00:48:37:  Straightforward code.
00:48:38-00:48:40:  I wanted to point that one out to get a
00:48:40-00:48:46:  sense of what it would be like to try to pull that off. How would you even start tackling that in Erlang if you
00:48:46-00:48:48:  were going to have the next
00:48:48-00:48:50:  version of Erlang that had, you know,
00:48:50-00:48:52:  they're stealing ideas from Elixir?
00:48:52-00:48:54:  Well, you've just got to change the Erlang
00:48:54-00:49:06:  parser a bit and then sort of do Yeah, the back quote wouldn't be too difficult. Basically doing
00:49:06-00:49:08:  it in the same way as Elixir does.
00:49:08-00:49:10:  I mean, Elixir just allows you to write Elixir
00:49:10-00:49:14:  syntax in the macro.
00:49:14-00:49:16:  Whereas if you're doing an
00:49:16-00:49:18:  Arlang Piles transform, you have to
00:49:18-00:49:26:  actually use the abstract syntax, which is what makes it difficult. So that in itself would be too difficult to do. The pipe falls, I don't know, I haven't
00:49:26-00:49:28:  looked at those. Also, I'd
00:49:28-00:49:29:  character transform while you're at it to
00:49:29-00:49:32:  transform the character stream before it gets to even being tokens.
00:49:33-00:49:34:  You could do even more fun things.
00:49:35-00:49:36:  Then we could start adding
00:49:36-00:49:38:  parentheses and shift the parentheses
00:49:38-00:49:40:  as well.
00:49:40-00:49:41:  You know, don't reinventing this.
00:49:41-00:49:42:  Who uses this promise everywhere?
00:49:44-00:49:52:  Yeah, so one of the things, you get a bunch of nice functionality by having quotes and back quotes
00:49:52-00:49:57:  and being able to generate a quote easily without knowing the internal representation.
00:49:58-00:50:03:  But having an internal representation that's straightforward is also very, very important.
00:50:03-00:50:05:  And it allows you to do very nice things.
00:50:06-00:50:11:  So one of the examples we have in Elixir is the assert macro for testing, right?
00:50:11-00:50:15:  So when you're testing Elixir code, we have the assert macro,
00:50:15-00:50:19:  and we don't have like assert equal, assert match, assert this, assert that,
00:50:19-00:50:21:  because assert is a macro.
00:50:27-00:50:27:  So when you say like A equals equals B, the macro can look and say, oh, we are trying to compare two things.
00:50:29-00:50:30:  So it gets those things, right?
00:50:31-00:50:39:  And it sees that we are trying to do a comparison. And when there is a failure, we emit a nice failure for you without you having to be explicit about it, without you having to say exactly what you're doing.
00:50:40-00:50:44:  for the most operations because we can just look into that and say,
00:50:44-00:50:45:  I know exactly what you're doing.
00:50:45-00:50:49:  You don't need to tell me, and I'm going to tell you a nice error report
00:50:49-00:50:52:  because we can get this information.
00:50:52-00:50:56:  So this is a third thing, and what Joey said of compiling the MIME types,
00:50:57-00:50:59:  and we use a similar trick for our Unicode.
00:51:07-00:51:12:  So we operations, like downcase, upcase, get the category, and they're very fast. And there's no runtime overhead, like trying to load your server or an ETS.
00:51:12-00:51:15:  Because at compilation time, we open up the Unicode files.
00:51:16-00:51:22:  We compile those to functions in a module, right, with pattern matching and everything.
00:51:23-00:51:24:  And that's what we use.
00:51:29-00:51:29:  And it's just a pattern matching at runtime with the bytes that you want to upcase or downcase.
00:51:30-00:51:36:  Related to that, I have a question because Elixir tried to provide all of these features,
00:51:36-00:51:42:  including using binaries underlying for strings and whatnot, before Erlang did it in the first
00:51:42-00:51:42:  place.
00:51:40-00:51:42:  Erlang did it in the first place.
00:51:43-00:51:46:  And as we go, Erlang is slowly adding these features.
00:51:46-00:51:48:  So there's going to be a switch to Unicode by default,
00:51:49-00:51:50:  and then there's going to be a bunch of maps.
00:51:51-00:51:54:  Is there some kind of plan in Elixir
00:51:54-00:51:58:  to break the internal implementation
00:51:58-00:52:01:  to work with the new Erlang stuff that's going to come out,
00:52:05-00:52:06:  or are're really going to keep your own implementation to avoid breaking some kind of compatibility.
00:52:08-00:52:09:  I know that right now you're not at version 1.0.
00:52:12-00:52:12:  So the question also extends to after 1.0,
00:52:16-00:52:18:  whenever you'll be providing these more advanced features and then the Erlang VM catches up on there.
00:52:19-00:52:21:  Yeah, that's a good question.
00:52:26-00:52:32:  I think it depends on at what level we are talking about the Erlang feature. So let's suppose that Erlang adds like a B string module that has a bunch of Unicode operations.
00:52:33-00:52:40:  At this point, I would say we are keeping the string module we have in Elixir because a lot of people use it.
00:52:41-00:52:44:  And I don't think it would make sense to break the compatibility.
00:52:51-00:52:57:  And there it and I don't think it would make sense to break the compatibility and there are some functions that would probably map better to Elixir style so I would leave it as it is but all the other things related to Nicole which is like being able to parse Elixir file or being able to parse like
00:52:57-00:53:06:  Erlang files with Unicode stuff this doesn't affect us right because it's related to Erlang on tooling. But in general, I'm going to use your
00:53:06-00:53:12:  question to make it to a broader point, right? So in general, I say a lot, we don't, I have as a
00:53:12-00:53:19:  philosophy, we don't wrap Erlang stuff. So we don't wrap an Erlang library just for wrapping it,
00:53:26-00:53:31:  right? Just so you can call it with the Elixir module and what basically what you're doing is delegating to our lane. We say like, don't do that, right? Just use the Erlang stuff. We want to work together.
00:53:31-00:53:38:  We are supposed to work together. And this is something that I also want to bring community
00:53:38-00:53:46:  wise. I want some people, I want eventually like people, Elixir developers going to Erlang conferences because they're just amazing.
00:53:47-00:53:52:  The first time I've been to an Erlang factory, it was just amazing, all the topics about distributed systems.
00:53:52-00:53:53:  And it was, like, fantastic.
00:53:54-00:53:58:  And so that's why I want to keep things as close as we can.
00:53:59-00:54:02:  And I'm being careful with a bunch of stuff, too.
00:54:05-00:54:05:  I know that Erlang R-serving is coming with maps.
00:54:10-00:54:12:  So I want to integrate maps nicely with Alexia and not have segregation in this area too.
00:54:13-00:54:17:  So my approach is to avoid segregation as much as we can.
00:54:19-00:54:22:  But sometimes if they're introducing a feature
00:54:22-00:54:25:  that comes much afterwards,
00:54:25-00:54:28:  I would probably worry more about retaining compatibility
00:54:28-00:54:31:  unless it's too big of a change.
00:54:33-00:54:36:  That would make the work much better together.
00:54:36-00:54:41:  On that line, have you looked at taking things that you were developing
00:54:41-00:54:46:  on the Elixir side and sending over as patches or pull requests over to
00:54:46-00:54:48:  Erlang? Yeah,
00:54:48-00:54:50:  I already sent some patches,
00:54:50-00:54:51:  things that I think
00:54:51-00:54:54:  that are broken
00:54:54-00:54:55:  and we need to improve,
00:54:56-00:54:57:  things that...
00:54:57-00:55:00:  I think the first patch I sent was to support
00:55:00-00:55:02:  I think file name
00:55:02-00:55:03:  or file lib wildcard.
00:55:05-00:55:06:  So we have the file lib wildcard,
00:55:07-00:55:07:  I think that allows you to do glob.
00:55:09-00:55:10:  So this is your path, right?
00:55:10-00:55:11:  Yeah.
00:55:13-00:55:13:  Yeah, so we can do globbing, this kind of stuff,
00:55:15-00:55:15:  and didn't allow star, star, right?
00:55:17-00:55:19:  So I didn't want to implement the whole thing and maintain a completely separate thing.
00:55:20-00:55:26:  to OTP so we can have a star star and traverse direct orders aggressively too
00:55:26-00:55:32:  so where we can I am sending patches and if the OTP teams say like oh would like
00:55:32-00:55:37:  to have this true I would very gladly send a patch you because it's less cold
00:55:37-00:55:44:  for me to maintain as well I'm curious how much pain have you taken on with you
00:55:44-00:55:48:  know by changing some of the defaults or has it been just basically painless?
00:55:49-00:56:07:  Like for a module, like casing I'm thinking of, like modules versus the functions, and then with strings, binaries versus the default, and shadowing versus just each one of these things where it's like a little bit of a surprise for early developers, they get into that.
00:56:08-00:56:12:  How many of those actually are burning you later or has it been pretty painless?
00:56:13-00:56:21:  It has been pretty painless, I would say, because we don't go much crazy, right?
00:56:21-00:56:29:  We don't go that crazy so we add some stuff but for example um the shadowing we do
00:56:29-00:56:35:  is just we just compile later to static single assignment which is uh basically changing the
00:56:35-00:56:42:  variable names when we are uh emitting their language type format and that's like that's
00:56:42-00:56:47:  you know that's very little work if compared if i had to do everything from scratch
00:56:47-00:56:54:  right so it's there's i think this would be like the the most complicated thing in our compiler
00:56:54-00:57:01:  probably this whole thing of doing the variables uh shadowing because we need to consider case
00:57:01-00:57:05:  receive uh how those work if you define a variable in a clause and not in the other.
00:57:06-00:57:11:  But it has been running stable when we have one book or the other,
00:57:11-00:57:15:  but it's like, give me 15 minutes and I have the book fixed.
00:57:16-00:57:19:  It's not really a pain.
00:57:19-00:57:23:  Yeah, but you compile Alexia down to Erlang, don't you?
00:57:27-00:57:27:  I compile to the Erlang abstract format, yeah.
00:57:29-00:57:30:  Yeah, so you don't go down to core.
00:57:33-00:57:39:  Yeah, it's something I want to do eventually, but I think being able to run Dialyzer
00:57:39-00:57:42:  and some of the tools we have today in Erlang,
00:57:42-00:57:45:  like Cover and so on,
00:57:45-00:57:47:  having those now,
00:57:47-00:57:49:  I treat it as more
00:57:49-00:57:51:  important, and it would also force
00:57:51-00:57:53:  me to stay
00:57:53-00:57:55:  closer to Erlang, which is something that I wanted
00:57:55-00:57:57:  to do in the first place, right?
00:57:57-00:57:59:  And maybe
00:57:59-00:58:01:  in two years, and I am a wiser man,
00:58:01-00:58:07:  we can remove those constraints and I know how to get the things we have in core
00:58:07-00:58:09:  and bring it to the language.
00:58:09-00:58:11:  So there are things that I want to have, for example,
00:58:12-00:58:14:  today, like list comprehensions,
00:58:14-00:58:17:  they are implemented in early extract format
00:58:17-00:58:21:  as their own format in the tree.
00:58:21-00:58:23:  But when it compiles down to core,
00:58:28-00:58:28:  it's just recursive functions and so on.
00:58:30-00:58:32:  And I really would like to have more powerful list comprehensions
00:58:32-00:58:33:  in this case.
00:58:34-00:58:36:  I would like to be able to
00:58:36-00:58:38:  not only work with
00:58:38-00:58:40:  lists, because we have this idea of enumerables,
00:58:40-00:58:48:  anything we can enumerate, so I would like to support that. It's one of the things I'd like to have. There is some nice papers from the Haskell community,
00:58:49-00:58:50:  like comprehensive comprehensions,
00:58:50-00:58:52:  which is about adding other operations,
00:58:52-00:58:56:  like order by, right, to this.
00:58:56-00:58:58:  And it's something maybe I'd like to experiment
00:58:58-00:58:59:  and have those two.
00:59:09-00:59:10:  And if I compile to In fact, on Power2Core, I would be able to do those now today. So that's one of the things that we don't get, but we can wait.
00:59:10-00:59:11:  Yeah.
00:59:14-00:59:16:  Well, I was asking, I mean, some of the problems Brian mentioned,
00:59:17-00:59:17:  they're sold.
00:59:18-00:59:18:  You're sold if you go to the core.
00:59:27-00:59:28:  You don't have this problem with scoping because core is scoped and all this type of thing for it. The funny thing you mentioned with Dialyzer is that Dialyzer actually works on core alloying internally.
00:59:29-00:59:29:  Yep.
00:59:30-00:59:36:  So I did a very quick hack to test if I could run it on LFE code,
00:59:36-00:59:37:  and it worked.
00:59:37-00:59:41:  You just have to change the functions that piles the code
00:59:41-00:59:42:  and generate the core to it.
00:59:50-00:59:50:  Unfortunately, Dialyzer is written in a very, very fixed way.
00:59:51-00:59:51:  So it only works in our language,
00:59:57-00:59:58:  and you'd have to reimplement the front end to make it configurable to which languages you'd want it to work on.
00:59:59-01:00:02:  Yeah, so – sorry, go ahead.
01:00:06-01:00:07:  Yeah, I'll just say – I sort of mentioned that to Costas sometimes, and he says, well,
01:00:08-01:00:10:  come along with a patch and we'll put it in. And I sort of
01:00:10-01:00:12:  say, yeah, but you guys could write the patch in one hour.
01:00:12-01:00:27:  For me, it would take a week, type of thing, and that's about as far as we get on this anyway for LFE because then I could run Dialyzer in an LFE code which I would like to do. Yeah, we were even
01:00:27-01:00:32:  discussing about having a place in the Erlang abstract format where we would put
01:00:32-01:00:36:  the core expressions instead of the Erlang abstract format
01:00:36-01:00:40:  and then Dialyzer would get it, would check from one place or the other
01:00:40-01:01:06:  but I completely agree with the front end and how we format messages. We would need to change those. hey should i start learning erlang or should i start learning elixir and so i i basically say
01:01:06-01:01:10:  it doesn't really matter because the hard parts are the same you know it's the same it's the same
01:01:10-01:01:15:  uh and so what's on the front uh you know you'll you'll find one or other that you like and so
01:01:15-01:01:27:  they're you know it'll be easy to pick the other one up but with with eric that you have written yourself, and you guys are using that language, right? And for production, for all of what you do,
01:01:27-01:01:28:  you're using Joxo, right?
01:01:29-01:01:30:  So, yeah.
01:01:30-01:01:35:  So the startup I was working on is kind of slowed down.
01:01:35-01:01:36:  About a year ago, I had to,
01:01:36-01:01:39:  my wife got pregnant and insurance and pay.
01:01:39-01:01:39:  Okay.
01:01:40-01:01:40:  Sorry.
01:01:45-01:01:45:  Yeah Yeah. Start being interesting. But we were using it for production. That startup is still kind of going in the back burner.
01:01:49-01:01:49:  So for some value of production, the answer is yes.
01:01:49-01:01:50:  Okay.
01:01:55-01:01:58:  I was just kind of curious, like when you see something like this come along, how do you evaluate it? I mean, as being a person that's actually written a language that's out there.
01:02:00-01:02:04:  The calculation's got to be a little bit different about how you look at something than how I look at it, maybe.
01:02:04-01:02:05:  Or maybe it's not.
01:02:06-01:02:06:  I don't know.
01:02:06-01:02:08:  Well, so it depends on the language.
01:02:08-01:02:16:  So with JAXA, one of the goals I had was to make a language that I could easily modify regardless of if anyone ever picked it up, right?
01:02:28-01:02:29:  The idea was that, okay, it's total everything, including libraries, is about 4,000 lines of code. I can maintain that without a problem and have no real impact on my productivity, right?
01:02:29-01:02:30:  Right, right.
01:02:33-01:02:33:  So in that situation, you know, it makes sense for me to use JOXA.
01:02:38-01:02:57:  Now, when it comes to other languages where that is not possible, there's a lot of factors that come into play. Now, between JAXA and Elixir, I think the biggest potential thing that comes into play is, for whatever reason, as wonderful as the Erlang community is, it's not the most inclusive of other language ideas.
01:02:58-01:03:06:  So we have this kind of dichotomy between Erlang and Elixir, at least for now, where if you're writing a system in Erlang, you're probably
01:03:06-01:03:10:  not going to depend on Elixir code. Whereas if you're writing a system in Elixir, you have this
01:03:10-01:03:13:  wonderful thing where you can depend on one or the other. But if you write something in Elixir,
01:03:25-01:03:27:  you're not going to have users from the it out there to the community or you're actually using it for your system.
01:03:27-01:03:32:  I think that's the question that you have to answer before you choose Elixir or Erlang.
01:03:33-01:03:38:  That is, do you want this to be used across both communities or do you want it to be,
01:03:45-01:03:50:  or do you not mind used in the Erlang community, right? So in the case of where you want to be used in both communities, you pretty much have to write it in Erlang. If you don't mind just being in the
01:03:50-01:03:54:  Elixir community, which is a huge proportion of stuff, I think, then Elixir is a great choice.
01:04:05-01:04:05:  And then there's all the other things when it comes to community is a moot point. Elixir has a wonderful, big community. There's two books out.
01:04:09-01:04:10:  We don't have to worry about Elixir going away or doing something crazy, right?
01:04:12-01:04:26:  Those points are moot at this point. So I think that question of which community are you targeting is the main driving question for whether you choose Elixir or Erlang at this point. Actually, the question, can I call Elixir from Erlang? I know I can do it the other way around, but it never occurred to me.
01:04:27-01:04:28:  Absolutely, you can.
01:04:28-01:04:30:  And it's quite simple.
01:04:30-01:04:31:  You can't or you can?
01:04:31-01:04:32:  You can.
01:04:32-01:04:33:  You can.
01:04:33-01:04:33:  Okay.
01:04:34-01:04:48:  It would just be a beam, right? compile them to Beam module outside in Elixir. And then I just stick them in my... You can use your normal build tools to compile both Elixir and Erlang,
01:04:48-01:04:50:  and you can actually mix Elixir and Erlang in the same project,
01:04:50-01:04:52:  in the same app without a problem.
01:04:52-01:04:54:  The only problem, and it's not a problem,
01:04:54-01:05:06:  is that you kind of have to do a mental mapping and the module name in Erlang, because they're just a little bit different. Yeah, that was my question.
01:05:07-01:05:10:  Thinking about that is, if you're calling Elixir from Erlang,
01:05:10-01:05:14:  how do you handle the Elixir module and function names as well, too, I suppose?
01:05:16-01:05:20:  So the function names, they have no change whatsoever.
01:05:25-01:05:26:  And all Elixir modules, they are prefixed with Elixir dot.
01:05:26-01:05:27:  So that's it.
01:05:27-01:05:28:  Okay.
01:05:31-01:05:32:  And now since the dot was removed, you, well,
01:05:34-01:05:34:  actually since our convention is CamelCase,
01:05:36-01:05:36:  you need to wrap them in single code.
01:05:41-01:05:41:  So open single code, Elixir dot, string, close single code,
01:05:42-01:05:45:  and then you call it normally. It's a regular atom. Let's try that.
01:05:46-01:05:47:  I have a related question.
01:05:49-01:05:49:  It's about all the languages you guys have designed.
01:05:53-01:05:54:  So how did they deal with concepts such as NIFs,
01:05:57-01:05:58:  so natively implemented functions calling to C from Erlang at that point,
01:06:05-01:06:09:  from the Erlang virtual machine? Is there any support for that in any of LFE, JAXA, Elixir, or whatever else. So for JAXA, at least, and I think it's true probably for all of the others,
01:06:10-01:06:13:  NIF is an Erlang VM concept, right?
01:06:13-01:06:16:  It has very little to do with the language itself.
01:06:18-01:06:28:  So JAXA, at the very least, it just works the same way it works in Erlang. You create your NIF, you call as if you were calling Erlang code, and it just works.
01:06:28-01:06:34:  There's an attribute about unload, do whatever there, replace it with the actual NIF call.
01:06:35-01:06:37:  That, I think, is just a normal attribute.
01:06:37-01:06:43:  I haven't actually looked internally, but I'm just assuming that just becomes a normal attribute in the module.
01:06:40-01:06:43:  becomes a normal attribute in the module.
01:06:44-01:06:44:  I haven't checked it.
01:06:45-01:06:45:  I suppose I have to check that.
01:06:46-01:06:48:  Yeah, that's exactly it.
01:06:48-01:06:52:  It's just a regular attribute, and that's it.
01:06:53-01:06:55:  So as long as a module, in that case,
01:06:55-01:06:58:  supports declaring attributes, you're going to be able to do that.
01:06:59-01:06:59:  Yeah.
01:07:00-01:07:00:  Yeah.
01:07:01-01:07:01:  Yeah.
01:07:06-01:07:06:  Yeah, I'd be very surprised if it couldn't do that.
01:07:08-01:07:08:  And, I mean, seeing none of the languages,
01:07:12-01:07:12:  the other languages sort of create new data types, you can't really.
01:07:17-01:07:26:  I mean, there's no problem from inside the NIF of even notice the difference they're just normal airline data structures
01:07:26-01:07:29:  that come in
01:07:29-01:07:30:  so yeah
01:07:30-01:07:31:  yeah
01:07:31-01:07:34:  I mean once you
01:07:34-01:07:37:  when you design your language you make the design
01:07:37-01:07:39:  decision that you want it to be compatible
01:07:39-01:07:40:  with the rest of airline
01:07:40-01:07:43:  then you get
01:07:43-01:07:44:  sort of get all this for free
01:07:44-01:07:46:  yes you get sort of get all this for free. I mean, yes, you get limitations.
01:07:46-01:07:50:  You can't design new data types, but you get the enormous benefit.
01:07:50-01:07:51:  You can work together with everything else,
01:07:52-01:07:54:  which I think outweighs most things, right?
01:07:55-01:07:57:  I mean, if you did your own language on top of our language,
01:07:57-01:07:59:  which wasn't compatible with the rest of the airline system,
01:08:06-01:08:06:  it would It would be basically unusable. Yeah, definitely. That's the first.
01:08:10-01:08:10:  So the first Alexey implementation, I said, well, let me try this.
01:08:11-01:08:11:  Let me try some ideas, right?
01:08:15-01:08:15:  I was trying to push as far as I could, not, let's say,
01:08:29-01:08:29:  respecting the airline boundaries that I could have. And it was, like, just completely unusable at the end of three, four months of exploration. It was just, you know, like you couldn't really hot code swap.
01:08:35-01:08:35:  If you wanted to hot code swap, you have to do like kind of three modules at the same time.
01:08:36-01:08:38:  It was really a Frankenstein.
01:08:39-01:08:39:  Yeah.
01:08:39-01:08:47:  Yeah. I mean, once you make that, I mean, you sort of, yeah, you have to make that decision. Once you've made that, that sort of very much influences what you can
01:08:47-01:08:48:  and can't do in the language.
01:08:49-01:08:51:  And, I mean, you can add features in your language,
01:08:51-01:08:54:  but they still have to map back to the outlanding side.
01:08:54-01:08:56:  I mean, I found a very simple case in LFE.
01:09:06-01:09:06:  I mean, coming from a list environment, you want to minus inside their names, right? That's how you separate words. That doesn't map cleanly across to our language
01:09:06-01:09:07:  uses underscore.
01:09:07-01:09:09:  So from this point of view,
01:09:09-01:09:10:  it looks slightly strange.
01:09:12-01:09:13:  And that's just,
01:09:13-01:09:15:  well, you just have to accept that.
01:09:15-01:09:16:  Otherwise, your code
01:09:16-01:09:18:  will not be able to call things.
01:09:20-01:09:21:  If I'm writing a behavior,
01:09:26-01:09:26:  the if I'm writing a behavior, the callback has to be called handle underscore call. Otherwise, it doesn't work.
01:09:31-01:09:32:  I'd much prefer to write handle hyphen call instead, but I can't do that.
01:09:33-01:09:34:  There was a suggestion maybe,
01:09:37-01:09:37:  some of my men suggested maybe you could change all the hyphens to underscores,
01:09:39-01:09:46:  but then again, then you don the deciding decision it's compatible,
01:09:46-01:09:47:  then you just have to live with it.
01:09:47-01:09:47:  And then,
01:09:48-01:09:49:  I mean,
01:09:49-01:09:49:  as I said,
01:09:49-01:09:50:  I think the benefits
01:09:50-01:09:52:  far outweigh any of the problems.
01:09:53-01:09:54:  With OTP,
01:09:55-01:09:56:  are you doing anything
01:09:56-01:09:56:  at that level?
01:09:56-01:09:58:  Are you abstracting anything?
01:10:06-01:10:08:  Are lines of Garrett's E2 to have just sort of a different view or you pretty much just straight up using all of the behaviors that are
01:10:08-01:10:10:  built in and the modules
01:10:10-01:10:12:  and so you have a few
01:10:12-01:10:14:  on top like strings and so on but
01:10:14-01:10:16:  as far as the things that people think
01:10:16-01:10:18:  of as OTP like application
01:10:18-01:10:19:  gen serve
01:10:19-01:10:22:  so for Alex
01:10:22-01:10:24:  here we
01:10:24-01:10:27:  we have the So for Elixir, you use the other stuff.
01:10:27-01:10:34:  The only thing we have is that we have convenience module that defines the callbacks for you.
01:10:34-01:10:37:  So you get more optional callbacks, right?
01:10:37-01:10:46:  So if you want to manage your server, you just need to implement like init and handle call
01:10:46-01:10:49:  and the other ones we have default values for them.
01:10:49-01:10:50:  That's all we do.
01:10:51-01:10:56:  We don't provide any other kind of abstraction at this level.
01:10:57-01:11:00:  And there are people playing with libraries
01:11:00-01:11:03:  or having macros that kind of try to hook everything
01:11:03-01:11:05:  because if you get a Gen Server,
01:11:05-01:11:08:  you need to write the handle call
01:11:08-01:11:11:  and then you need to write the front-end function
01:11:11-01:11:13:  that's going to call that callback.
01:11:13-01:11:16:  And people, they have macros that kind of do both for you.
01:11:17-01:11:28:  And so you have like much more concise Gen Servers, but we don't have that in Elixir. And the reason for that,
01:11:28-01:11:33:  we didn't take a step in this direction. It's because I think the abstraction leaks,
01:11:33-01:11:41:  you still need to know what needs to be generated at the end when you use the libraries. So I don't
01:11:41-01:11:47:  feel it makes sense because if the abstraction is leaking and they need to know the original way, I prefer that Elixir has the original way.
01:11:48-01:11:58:  And then people, when they feel comfortable enough, they can give the next step and use a better abstraction or something that will allow them to be more concise.
01:11:59-01:12:06:  So you mentioned macros there, do you start to see the kind of thing that LISPs have where every project has
01:12:06-01:12:10:  its own subset of the language that they define for the macros that makes it kind of hard to
01:12:10-01:12:22:  jump into any random project? I haven't seen it yet. We try to do some education in this area,
01:12:22-01:12:27:  like, and I think other languages that were very efficient in macros,
01:12:27-01:12:27:  they do the same.
01:12:28-01:12:30:  Like, don't use macros if you don't want to,
01:12:31-01:12:33:  not just because you can change things completely,
01:12:33-01:12:37:  but because you can simply do crazy stuff,
01:12:37-01:12:40:  like define, you can skip the hygiene, right,
01:12:40-01:12:47:  and insert a bunch of variables in the user code. That's just insane. It's like, please don't do that.
01:12:49-01:12:49:  Yeah, I saw your documentation.
01:12:53-01:12:54:  You saw warning people to avoid macros unless they really need it.
01:12:56-01:12:57:  I agree.
01:12:59-01:13:01:  That's a sensible recommendation.
01:13:04-01:13:05:  They say it's the first rule of the macro club, right? It's don't write macros.
01:13:06-01:13:09:  Yeah They say it's the first rule of the macro club, right? It's don't write networks. Yeah, yeah, yeah.
01:13:09-01:13:18:  But I think that it can happen that people, they will come with their own abstractions.
01:13:18-01:13:22:  And then when you jump into a project, you need to face those abstractions, right?
01:13:22-01:13:23:  You need to understand those abstractions.
01:13:20-01:13:22:  face those abstractions, right? You need to
01:13:22-01:13:24:  understand those abstractions, but I
01:13:24-01:13:25:  don't think it
01:13:25-01:13:28:  would be much different from
01:13:28-01:13:30:  a project that uses each
01:13:30-01:13:32:  set of new abstractions
01:13:32-01:13:34:  and you need to understand them.
01:13:34-01:13:36:  What is an HE task, right? You need to go
01:13:36-01:13:38:  there and understand that
01:13:38-01:13:40:  when you're jumping to
01:13:40-01:13:41:  other people's code.
01:13:43-01:13:48:  But I definitely agree that it allows people if they want and they want to
01:13:48-01:13:53:  completely ignore every warning put in front of them they can just go crazy and write very crazy
01:13:53-01:14:03:  stuff so if we could just now pick up and talk a bit about uh community and how a conversation we
01:14:03-01:14:07:  had a few podcasts back was about how the Ruby community seems to get a lot
01:14:07-01:14:15:  right as far as how they organize and how they, uh, just on a social level. And, uh, and so how
01:14:15-01:14:20:  Elixir, this interest that we're getting, where people are coming from Ruby, they're coming from
01:14:20-01:14:25:  closure community. Interestingly, uh, I'm seeing a lot of people from that community hopping over.
01:14:27-01:14:27:  Could we talk some about that?
01:14:28-01:14:28:  Did you want to lead off, Simon?
01:14:29-01:14:30:  Did you have particular questions?
01:14:34-01:14:34:  Yeah, I think Jose started things off really, really well.
01:14:36-01:14:36:  I mean, it's a welcoming community.
01:14:40-01:14:48:  There's documentation that's clearly meant have all of the answers yet.
01:14:48-01:14:52:  So the, the mailing list conversation is pretty much always useful.
01:14:53-01:14:56:  So like on all of those levels, things are going really, really well.
01:14:56-01:15:03:  I'm hoping that we can keep this kind of, we keep bringing in new people from other
01:15:03-01:15:10:  places and I'm having fun watching people who I used to know through XML or through Ruby or through other places.
01:15:10-01:15:14:  They're all turning up in Elixir, and I just love the magnetism.
01:15:20-01:15:29:  year we we did a bit of Erlang school and it was really nice how one month in people uh once they
01:15:29-01:15:35:  got past the the basics of language the conversation became about distributed computing concepts and
01:15:35-01:15:39:  we're doing another round of Erlang school this summer and interestingly after we had the first
01:15:39-01:15:47:  week or the first month of uh around language basics uh a lot of people started jumping in and we had a mix of half Erlang developers
01:15:47-01:15:48:  and half Elixir developers.
01:15:48-01:15:51:  And these were people that had never been part of Nash FP,
01:15:51-01:15:52:  but they were coming in because of this.
01:15:52-01:15:56:  And we're quickly past the syntax and the language parts again.
01:15:56-01:15:59:  And we're now we're talking about distributed computing.
01:16:08-01:16:08:  So I just love, I love that. You know, the conversation is all about causality and all the sort of things that Chris Micklejohn talks about on the Distributed podcast.
01:16:11-01:16:12:  And so that's which is really nice.
01:16:17-01:16:17:  Yeah, that's exactly my feelings when I've been to the first telling factory.
01:16:21-01:16:32:  I was like, whoa, I know nothing of this, but I feel great. It was it was really, really interesting. And it's something that I am looking forward to hearing people talking about.
01:16:32-01:16:42:  When people have not explored this area yet, and when they come and they start to hear out of it and go to the talks, they'll be very impressed too.
01:16:43-01:16:44:  And that will be very interesting.
01:16:40-01:16:44:  They'll be very impressed too, and that will be very interesting.
01:16:45-01:17:08:  Thinking of sort of the rosy future, like how this could really work out, I'd love to hear what Robert and Joe and what everyone actually thinks will happen five years. Owling is a bad game, especially when you're being recorded. But more or less what you would like to see happen rather than what you think for sure is going to happen.
01:17:09-01:17:10:  Just with –
01:17:10-01:17:15:  With Owling generally or –
01:17:15-01:17:22:  Well, Owling and then Elixir, all the excitement, interest around there, and how will this all play out?
01:17:26-01:17:26:  How will these work together and what's this community going to look like maybe?
01:17:28-01:17:29:  Or what would you like to see happen? I guess it's really more of the question.
01:17:30-01:17:32:  Can I answer that a bit? Yes, please.
01:17:32-01:17:34:  I think one of the
01:17:34-01:17:36:  I don't think
01:17:36-01:17:38:  programming languages need to change
01:17:38-01:17:49:  if hardware doesn't change because whenever you make a sort of change in hardware, then you sort of invent new programming languages
01:17:49-01:17:50:  to program that hardware.
01:17:51-01:17:54:  And so Erlang's kind of had a little jump forward
01:17:54-01:17:56:  when multicores came along.
01:17:56-01:17:58:  I mean, Erlang had been sitting around for a long time,
01:17:58-01:18:02:  but I think that's still the case, actually,
01:18:02-01:18:11:  because the thing that looks to me to be very interesting is the sort of – first of all, the multicores came, and then they went on to the desktop.
01:18:12-01:18:31:  And so a desktop computer might have a quad core on it or something like that. very interested in are these very low power arm processors where you can put about 24 or 48 of them onto a very small form factor
01:18:31-01:18:37:  and then stick in 20 gig of memory in a terabyte disk
01:18:37-01:18:40:  and make that into a little module that consumes about 30 watts or something.
01:18:41-01:18:42:  So I think we're going to see...
01:18:44-01:18:45:  It's like the Chuck Moore...
01:18:45-01:18:46:  If you make a
01:18:46-01:18:48:  single rack-mounted computer, I think
01:18:48-01:18:50:  it's Hewlett-Packard to make a module that will
01:18:50-01:18:52:  fit into there. You're probably going to have racks
01:18:52-01:18:53:  with
01:18:53-01:18:56:  400 or 500 cores
01:18:56-01:18:57:  and
01:18:57-01:19:00:  terabytes of RAM and a lot of things
01:19:00-01:19:02:  available fairly cheaply
01:19:02-01:19:04:  in the near future.
01:19:07-01:19:08:  They available fairly cheaply in the near future. They're almost at the point where you're going to buy these modules at home.
01:19:12-01:19:16:  And then that's really going to pose the problem of how the heck do you program those things because you've got to turn your program from monolithic serial programs
01:19:16-01:19:19:  into non-shared memory concurrent programs.
01:19:20-01:19:26:  And then I think there's going to be another sort of emergence of interest in the language if they do that properly. Well, there's only Erlang and Alexia that do it properly.
01:19:27-01:19:30:  So everybody's going to be forced to use it if they want to program these things.
01:19:32-01:19:33:  Right.
01:19:37-01:19:41:  I would say one thing with Erlang.
01:19:43-01:19:46:  The Erlang language is not really being hyped very much these days.
01:19:47-01:19:52:  It's actually quite quiet about it, but it is being used quite a lot.
01:19:52-01:20:01:  I mean, we see from the business side that there are actually quite a few companies using Alang, and many don't say anything, which is not surprising.
01:20:01-01:20:02:  It's just a tool, so what will I say?
01:20:08-01:20:08:  Or a competitive advantage they don't want to talk about. Or a competitive advantage, yeah, we keep silent about.
01:20:11-01:20:11:  But I think if you look at, say, React's customer list,
01:20:13-01:20:13:  the number of companies using React,
01:20:15-01:20:16:  they probably don't even know they're using it.
01:20:26-01:20:28:  Well, they don't. that if they write their application in Erlang and talk through React, there's no impedance mismatch in the data structures between what's in the database and their application.
01:20:28-01:20:31:  So it will go a bloody night faster than if they were using SQL or something.
01:20:32-01:20:36:  Then they'll start tweaking and sort of, ooh, that's an interesting idea.
01:20:48-01:20:49:  Well, yeah, I mean, it's the same thing as with RabbitMQ. I mean, I guess most RabbitMQ users perhaps have no idea it's written in Erlang or interested in using it in Erlang.
01:20:52-01:20:56:  I just think, I know, so Erlang is being used a lot, but we're not sort of, well, I think, correct me if I'm wrong here, but we're not really much
01:20:56-01:20:59:  into the hype side of everything.
01:21:05-01:21:06:  It's the least hyped language. It's the least hyped technology in the world, I think. It's underhyped.
01:21:09-01:21:09:  I think there has been a phase about hype.
01:21:13-01:21:13:  I think it happened, part of it for Erlang, the language itself,
01:21:17-01:21:17:  after there was this Ruby blog post about Ruby is a ghetto or whatever.
01:21:20-01:21:26:  And then people thinking Ruby doesn't scale. And then they went into Erlang, and then when Erlang didn't do exactly what they wanted, they went to Clojure and they went to Scala.
01:21:27-01:21:30:  And I think there's always a wave of language hipsters
01:21:30-01:21:33:  that just surf from language to language and will never really settle down.
01:21:34-01:21:37:  And Elixir probably has quite a few visits from them.
01:21:37-01:21:42:  The nice thing is that all of these visits at some point,
01:21:46-01:21:46:  a All of these visits at some point, a few of them will stay there and new programmers will just join the wave and whatever.
01:21:57-01:21:57:  So I think the question will be what happens once that wave has entirely quit Erlang and what will happen when that wave also has mostly quit Elixir and other languages?
01:22:01-01:22:06:  Because right now, both languages are still part of that cycle still a bit. We've inherited the Swedish culture you see, because in the Swedish culture
01:22:06-01:22:08:  you're not allowed to hype things and you can possibly
01:22:08-01:22:10:  stand there and say, well, that's ever so good.
01:22:10-01:22:12:  It's perfectly okay for other people
01:22:12-01:22:14:  to say that, of which we would then deny it.
01:22:15-01:22:17:  It's a non-self-promoting
01:22:17-01:22:26:  culture, so it's i mean we know it's
01:22:26-01:22:33:  wonderful we can't say we can't say that the fact we don't and the fact we don't say that tells them
01:22:33-01:22:39:  it is right so it's backwards completely backwards yes i think elixir has been similarly cautious i
01:22:39-01:22:46:  mean the two biggest bursts that i can remember are joe's post on it generated huge interest and dave thomas
01:22:46-01:22:52:  generated some huge interest as well um it's not been the elixir community jumping up and down and
01:22:52-01:22:57:  saying hey look at us it's been hey we're working on something and other people say that thing is
01:22:57-01:23:20:  cool yeah that's that's true uh joe's post it it made it made a huge impact, Joe. I'm tracking stuff, I can see how it goes, and people are frequently mentioning your post, and it's also done some kind of approval.
01:23:20-01:23:23:  like Joe from the creator of Erlang
01:23:23-01:23:24:  he
01:23:24-01:23:27:  approves it
01:23:27-01:23:29:  and people use that to
01:23:29-01:23:30:  you know to approve themselves
01:23:30-01:23:32:  moving that direction too because
01:23:32-01:23:34:  if Joe did I can do it
01:23:34-01:23:36:  I should certainly do it too
01:23:36-01:23:37:  right
01:23:37-01:23:40:  and of course
01:23:40-01:23:42:  the books both from Simon and Dave
01:23:42-01:23:44:  they cause a huge impact
01:23:44-01:23:47:  too and people are absolutely wonderful.
01:23:47-01:23:49:  I mean, and the timing is brilliant.
01:23:50-01:23:52:  Part of a community is about advocacy.
01:23:52-01:23:57:  Another part is building the actual product.
01:23:57-01:24:01:  And I'm curious, what would you like from the community, Jose?
01:24:01-01:24:02:  How can we help?
01:24:03-01:24:07:  And how can the listeners help well at this point uh
01:24:07-01:24:16:  the the the way to help is to just come uh try the language out give your feedback uh what could
01:24:16-01:24:21:  improve what could not improve and then and you just need to come with the mindset that you
01:24:21-01:24:26:  you need to still interface a lot with learning.
01:24:26-01:24:28:  And if you want to do something novel
01:24:28-01:24:31:  or something that you feel like could be different,
01:24:31-01:24:32:  you need to write it yourself.
01:24:33-01:24:37:  Are there any bits of tooling in particular that are gaps,
01:24:37-01:24:39:  or is that not a thing that seems to be missing?
01:24:40-01:24:40:  I mean, you have, of course, Mix,
01:24:41-01:24:46:  and you have the Le the line again like things and you know so uh is there anything out
01:24:46-01:24:54:  there to be like i wish yeah so uh so one of the things that comes so a lot of people uh and both
01:24:54-01:25:00:  my background and i think from dave thomas uh background and the audience we have access they
01:25:00-01:25:06:  are uh rails they are rails developers ruby developers and when they come they are Rails developers, Ruby developers, and
01:25:06-01:25:07:  when they come, they're expecting for something
01:25:07-01:25:09:  similar, right?
01:25:09-01:25:11:  And this is something that we don't have, and I
01:25:11-01:25:13:  made a huge mistake because it's
01:25:13-01:25:15:  something that I'm after also
01:25:15-01:25:17:  because that's how my company makes
01:25:17-01:25:19:  money. So
01:25:19-01:25:21:  I want to get there eventually,
01:25:21-01:25:29:  and I did the mistake of doing a proof of concept and leaving it because I wanted to evaluate it myself as well.
01:25:30-01:25:34:  I wanted to see how well we could do those things and how well I can build that.
01:25:35-01:25:38:  Let's say a Chicago boss equivalent to Alex here.
01:25:38-01:25:43:  And I put it online so everyone is going there and using that thing.
01:25:44-01:25:46:  But I don't want people to use that.
01:25:46-01:25:51:  I want people to go out of their way at this point and try to build it themselves
01:25:51-01:25:59:  and try to see what novel ways they can bring, how well we can interface that with Erlang
01:25:59-01:26:06:  or if there are new concepts like CQRS that we can integrate better in our environment because of
01:26:06-01:26:08:  how the virtual machine works.
01:26:10-01:26:10:  That's
01:26:10-01:26:12:  something that if we do it right, it's going
01:26:12-01:26:14:  to appease very much for that
01:26:14-01:26:16:  community. That community would really
01:26:16-01:26:18:  like to come and explore it further.
01:26:18-01:26:20:  It would be a great way to attract
01:26:20-01:26:22:  even
01:26:22-01:26:23:  more people because
01:26:23-01:26:25:  I think that
01:26:25-01:26:27:  people that are trying
01:26:27-01:26:30:  Elixir, they are still mostly
01:26:30-01:26:31:  early adopters.
01:26:31-01:26:32:  They are still early adopters.
01:26:34-01:26:35:  Well, very
01:26:35-01:26:37:  cool. This has been
01:26:37-01:26:38:  super good.
01:26:39-01:26:42:  I think we're probably now at the spot for our
01:26:42-01:26:42:  picks of the week.
01:26:44-01:26:45:  Let's see.
01:26:47-01:26:47:  Would you like to go first, Jose,
01:26:49-01:26:50:  on your pick of the week?
01:26:50-01:26:51:  Oh, sure.
01:26:55-01:26:56:  I have, so one of the things I am enjoying studying lately,
01:26:58-01:26:58:  it's Rx Extensions.
01:27:01-01:27:07:  It's from Microsoft.net. They actually have a very good amount of research coming from Microsoft.net, they actually have a very good amount of research coming from Microsoft.
01:27:08-01:27:12:  Eric Meyers' group before he left and Matthew Podwasaki and that crew, right?
01:27:13-01:27:14:  Yeah, exactly.
01:27:14-01:27:17:  And they have a bunch of interesting research.
01:27:17-01:27:19:  I'm frequently reading their papers.
01:27:19-01:27:22:  They have very nice ideas in F-sharp, for example.
01:27:20-01:27:25:  very nice ideas in F sharp, for example. Um, and,
01:27:25-01:27:30:  and it's nice because you have like C sharp and they are bringing slowly,
01:27:30-01:27:34:  slowly, uh, functional constructs into, into C sharp.
01:27:34-01:27:38:  And sometimes it's nice to see how people react to that and how they embrace
01:27:38-01:27:42:  their ideas. So they have a link, which is also fantastic. Um,
01:27:49-01:27:56:  so it's very interesting. rx is the thing i'm uh exploring also i also got a book on f sharp to learn it for real but i haven't read it yet so i'm not going to pick it as a pick
01:27:56-01:28:02:  but i want to point to active extensions because uh it's a way for you to treat uh it's basically
01:28:02-01:28:06:  functional or active programming right so how can you treat events in a functional way?
01:28:07-01:28:11:  And the examples are very cool, even more when they come to UI.
01:28:11-01:28:14:  So there is a bunch of fantastic stuff in there.
01:28:14-01:28:21:  And my other two picks will be the, let me get it here.
01:28:21-01:28:30:  It's the Introducing Elixir book from Simon and the Programming Elixir book from Dave Thomas from PagMap Programmers.
01:28:30-01:28:34:  So I'm sending the links for those two.
01:28:34-01:28:38:  And obviously Elixir, but I think this one is a given.
01:28:38-01:28:39:  Yeah, yeah.
01:28:39-01:28:41:  Those links will definitely be up there.
01:28:41-01:28:42:  Oh, great.
01:28:47-01:28:53:  How about you, Simon? Yeah, I'd like to add to what Jose said. I'm really happy with introducing Elixir. But one of my favorite pieces is that David Eisenberg,
01:28:53-01:29:00:  my co-author, has been doing etudes. And etudes are exercises that are organized roughly according
01:29:00-01:29:06:  to chapter. They go a bit beyond. On the Er erlang side i've been watching those happening as meetups on
01:29:06-01:29:11:  elixir i haven't seen it happen yet but it's available for free it's available on github if
01:29:11-01:29:18:  you want to start making changes suggestions um making it your own so etudes for elixir would be
01:29:18-01:29:26:  my definite pick of the week ah cool cool uh i think simon i saw a meetup that they were doing, the Attitudes for Elixir.
01:29:26-01:29:27:  Excellent.
01:29:27-01:29:30:  I think it popped out already at least once.
01:29:30-01:29:31:  Beautiful.
01:29:32-01:29:32:  Okay.
01:29:33-01:29:34:  Just going across my screen here.
01:29:34-01:29:36:  Robert, how about you?
01:29:36-01:29:36:  Do you have a pick of the week?
01:29:38-01:29:40:  I'm going to be completely different.
01:29:40-01:29:40:  Okay.
01:29:46-01:29:47:  There's And there's one site I love. It comes all the time, and that's XKCD.
01:29:47-01:29:48:  Uh-huh.
01:29:49-01:29:49:  Yes.
01:29:51-01:29:51:  Yeah, it's fantastic.
01:29:53-01:29:54:  So that's definitely my pick, right?
01:29:57-01:30:01:  And it keeps coming again, and now they've got a very nice one on privacy with all these things coming up with attacks on the privacy.
01:30:01-01:30:11:  I think they're just a wonderful site the burrito one uh just the other day right uh yeah the exhibitionist uh yeah yeah i think we'll link directly to that one yeah okay
01:30:11-01:30:19:  very cool uh how about you joe um yeah i've i've got something completely different as well um
01:30:20-01:30:26:  for a long time i've been interested for a very long time, I'm interested in how you organize information on a computer.
01:30:27-01:30:39:  And I just like the idea of organizing things in small cards, you know, like if you imagine a Twitter entry as a little card.
01:30:39-01:30:47:  And I see this sort of idea occurring again and again and again so various times i i have i been interested
01:30:47-01:30:53:  in systems that can manage these cards automatically or do things with them so so um i've now found
01:30:53-01:30:59:  trello.com which is the latest in in in the line of things which which actually work quite nicely
01:30:59-01:31:07:  and there's a mobile phone app um for them uh which which puts things onto little cards and sort of organises them
01:31:07-01:31:07:  in a nice way.
01:31:07-01:31:14:  And it looks very much to me, it comes out of Kanban boards as a way of organising things.
01:31:15-01:31:25:  And I realised, in fact, they're the same as, I was very interested in Chandler, a system called Chandler, and a book called Dreaming in Code, if you've ever read it. It's very good. And it's also rather like the TiddlyWiki.
01:31:29-01:31:30:  So it's always themes sort of join together.
01:31:33-01:31:33:  So I think I'm interested in this problem.
01:31:35-01:31:35:  There's actually a book, a chapter in my book,
01:31:36-01:31:37:  The Sherlock Problem.
01:31:40-01:31:48:  And that is the problem I'm trying to solve, and these are partial solutions to it, is when I have an idea, I sort of enter it into the computer somewhere in a little window,
01:31:48-01:31:49:  imagine a Twitter window.
01:31:50-01:31:54:  And then I sort of, I can imagine myself, I want to press the Sherlock button
01:31:54-01:31:59:  and I want to find it the most similar idea on the planet to that.
01:31:59-01:32:01:  Have I had a new idea?
01:32:07-01:32:12:  Or where do I put it in in a sort of hierarchy of ideas and organize how do i organize it is it wrong with files and directories is is um given that you've given that you've got an idea
01:32:12-01:32:15:  you type it into a little window and then you've got to make a design decision you have to store
01:32:15-01:32:26:  in a file where you have to choose a name for the file that's pretty in and then you've got to choose a machine to put the directory
01:32:26-01:32:30:  in and then you can never remember later and and and you know i've got millions of files all over
01:32:30-01:32:35:  the place on hundreds of computers and i can't find stuff so so really really when you get a
01:32:35-01:32:45:  new idea you don't want to put it in a separate file you want to merge it in with an existing structure of information so i I've been looking at ways to do that for the last 20 years and slowly finding things that
01:32:45-01:32:46:  help you do that.
01:32:46-01:32:51:  So the latest one is Trello.com and they've got a very nice mobile app, which unfortunately
01:32:51-01:32:52:  isn't open source.
01:32:52-01:32:56:  So if we put pressure on them, perhaps they'll make an open source.
01:32:56-01:33:05:  If anybody has got an Android application that can just take a little note and take a photo and then send it to a web address in a portable
01:33:05-01:33:06:  format.
01:33:06-01:33:09:  I would love to know how to do that because I'm not very good at programming Android.
01:33:10-01:33:13:  So my tip with Trello.com, which I'll write it down here.
01:33:13-01:33:14:  Okay, cool.
01:33:14-01:33:14:  Yes.
01:33:16-01:33:26:  And sign up for their app and try it write the server. If somebody could do the
01:33:26-01:33:28:  client bit in an
01:33:28-01:33:29:  Android device.
01:33:30-01:33:31:  Like Trello.com?
01:33:32-01:33:33:  Trello, just like that.
01:33:33-01:33:35:  T-R-E-L-L-O.
01:33:36-01:33:37:  The mobile app is very good, actually.
01:33:38-01:33:39:  It helps you organise your ideas.
01:33:45-01:33:46:  It becomes addictive in about an hour or so. Well, cool.
01:33:46-01:33:47:  Yeah, I've used it.
01:33:47-01:33:47:  It is good.
01:33:48-01:33:51:  I mean, if you played with Kanban boards, they're quite fun.
01:33:51-01:33:54:  I've written some Kanban board software myself in JavaScript.
01:33:54-01:33:56:  It seems a nice way to organize information.
01:34:07-01:34:07:  No, it's like I have this – once you run the Chandler book and the Chandler design notes. You have a good post on that as well, right?
01:34:09-01:34:12:  So that would be a thing for us to add in the links on Chandler.
01:34:14-01:34:15:  I've got a lot more ideas than – Than what was in the post, okay.
01:34:16-01:34:28:  Well, I think I'm allergic to to-do lists and to-do list generators because to-do lists and to-do list generators, because to-do lists assume that, you know, you make a list of ideas and then you tick them off.
01:34:28-01:34:31:  And, you know, they're binary. You've done it or you haven't done it.
01:34:31-01:34:34:  But I don't believe in that. Jobs aren't done or not done.
01:34:47-01:34:52:  So I believe in the triage system, which three categories. It's the triage system, it's now,
01:34:52-01:34:57:  later and done. So now people get immediate attention because they've had a heart attack
01:34:57-01:35:08:  or something. And then if it's not now, they're in later. And you only get to later when you've done all the now jobs. And then you're in later. And then when you finish in later, you get to done and you can be slussed out.
01:35:09-01:35:09:  OK.
01:35:09-01:35:12:  But then what they realize, any one of those jobs can change state.
01:35:12-01:35:12:  OK.
01:35:12-01:35:15:  So later could suddenly have a heart attack and they're immediately put into now.
01:35:16-01:35:17:  OK.
01:35:28-01:35:28:  So OK, you have jobs which you move between categories and then you have a log that you log what's going on within that within that job.
01:35:30-01:35:30:  And that's how actually how I think, you know, you come to work.
01:35:31-01:35:31:  What are you going to do now?
01:35:32-01:35:32:  What would do that?
01:35:35-01:35:39:  And then you move things from your now to your later list. And really, I'd like it.
01:35:46-01:35:46:  I'd like a little and sort of watching everything I type into the internet saying, well, hang on, you did that a year ago or three years ago or somebody else did that.
01:35:47-01:35:51:  It's called the NSA.
01:35:53-01:35:54:  Unfortunately, there's no API to get the data back out.
01:35:55-01:35:55:  Yes, I mean, can't they?
01:35:57-01:36:07:  Why don't they just change it for a backup service? Excuse me, I lost all my confidential terrorist mail. How about you, Fred?
01:36:07-01:36:09:  What pick of the week do you have this week?
01:36:10-01:36:11:  I have two
01:36:11-01:36:14:  picks. The first of which
01:36:14-01:36:16:  is Erlang Bookmarks.
01:36:16-01:36:18:  That's a little wiki about all kinds
01:36:18-01:36:20:  of stuff that people from the community
01:36:20-01:36:22:  have been assembling in a directory
01:36:22-01:36:24:  for different things about the language.
01:36:24-01:36:28:  They have entry points for a directory for different things about the language. So they have entry points for language for beginners.
01:36:28-01:36:33:  They have books, community exercises, different kinds of documentation tools
01:36:33-01:36:38:  for debugging, editors, and whatever there is there.
01:36:38-01:36:42:  Second one I want to put in there, I think a couple of weeks ago,
01:36:42-01:36:45:  I might have suggested Recon, which is a library I was
01:36:45-01:36:55:  working on. And lately, I released version 1.1 of it. And that version actually has something
01:36:55-01:37:01:  called Recon Alloc that talks about memory allocators in Erlang. And in the Erlang in
01:37:01-01:37:11:  production podcast we had a couple of months ago, I did mention having issues with binaries and whatnot and all kinds of research I was doing about that.
01:37:28-01:37:28:  And a lot of the things I found out were put inside that library with documentation about how to understand a bit of the allocators and a few functions that I have written with the help of Lucas Larson at Ericsson to make sure that you could find issues that you had with memory.
01:37:37-01:37:38:  And this is a little module that you can drop in and use to do a quick analysis about the state of your memory allocators in Erlang.
01:37:39-01:37:39:  And Eric?
01:37:45-01:37:49:  I'm actually going to recommend Joe's A Week with Elixir. I think it's absolutely worth reading, especially for current Erlang folks.
01:37:49-01:37:50:  Oh, that's a good one.
01:37:50-01:37:51:  Yeah, that's great.
01:37:52-01:37:55:  This week, I have two picks on Peep Code.
01:37:56-01:37:58:  There's an episode with Jose.
01:37:58-01:38:01:  It's called Meet Elixir, and I'll have the link for that.
01:38:05-01:38:07:  And it's great. It has a really unconventional format. And it's very organic.
01:38:07-01:38:11:  I'm not sure how the whole session came together, but it looks like it was almost an accident.
01:38:11-01:38:12:  It just turned out well.
01:38:12-01:38:14:  And they happened to be recording it.
01:38:14-01:38:15:  But it's just brilliant.
01:38:15-01:38:16:  Nice flow.
01:38:25-01:38:25:  And then there called Elixir is Not About Syntax. It's a great blog post.
01:38:27-01:38:28:  It's on hacking Devin Torres.
01:38:29-01:38:29:  And so I'll have a link for that as well.
01:38:31-01:38:32:  And those are my picks.
01:38:35-01:38:35:  And I tell you, I'd really like to say thank you to you all.
01:38:36-01:38:36:  This has been a treat.
01:38:38-01:38:46:  It's a double feature that we've recorded today. And thanks, Jose, for doing all you've done. Thank you, Jose. Yes, very good. Yes. Definitely. I look forward to meeting you in London.
01:38:47-01:38:48:  Yes, definitely.
01:38:49-01:38:51:  Who else is coming to London?
01:38:51-01:38:53:  I thought Dave Thomas is coming.
01:38:54-01:38:55:  Yeah, he's coming.
01:38:56-01:38:58:  Robert, Brian, Simon, any of you coming too?
01:39:05-01:39:05:  And Bruce Cade I think so, but I don't know yet. I'll be up there too, but I'll be at a conference right next door.
01:39:08-01:39:08:  I'll be at NDC London, and so I'm going to try to sneak out of there.
01:39:12-01:39:13:  I'm going to sneak over and see if I can hang out with you guys.
01:39:25-01:39:31:  But NDC London is going on, and I'm to see CQRS and Elixir. Speaking of conferences, I've just given my confirmation that I will be at the
01:39:31-01:39:34:  Airline Factory Light in Toronto, November 23.
01:39:34-01:39:39:  So, yeah, if we have Canadians or people in the Great Lakes area in the United
01:39:39-01:39:46:  States that feel like crossing the border to go to Factory Light, there's one that's going to be there also. I might be able to make that.
01:39:47-01:39:55:  Awesome. And we are having, and then it's far away, so there is time for planning. February
01:39:56-01:40:07:  next year here in Poland, we are going to have a Lambda Days and they are just organizing it. They're putting the speakers up. Michal from Earning Solutions is organizing it.
01:40:07-01:40:11:  So if anyone wants to come visit Poland, that would be a good time, too.
(End of transcription)

You can listen to this episode on Spotify https://open.spotify.com/episode/6UqvG1H4w6wS93NqsHCGYr?si=7KrxAT9zT5mnfkDAsu-pOw