m1dnight_

Activity Graph

Page 1 of 2 | Next »

2019-09-12

[19:01:44] m1dnight_: Ping timeout: 276 seconds

2019-09-10

[18:15:59] m1dnight_: has joined #elixir-lang

2019-09-08

[08:42:57] m1dnight_: Quit: WeeChat 2.4
[09:05:22] m1dnight_: has joined #elixir-lang
[13:34:43] m1dnight_: Quit: WeeChat 2.4

2019-09-07

[16:27:07] m1dnight_: Ping timeout: 245 seconds
[22:47:30] m1dnight_: has joined #elixir-lang

2019-09-06

[15:36:37] m1dnight_: Ping timeout: 244 seconds
[15:40:01] m1dnight_: has joined #elixir-lang

2019-09-05

[04:22:58] m1dnight_: Ping timeout: 245 seconds
[04:26:04] m1dnight_: has joined #elixir-lang
[04:30:47] m1dnight_: Ping timeout: 258 seconds
[04:38:46] m1dnight_: has joined #elixir-lang
[04:45:53] m1dnight_: Ping timeout: 245 seconds
[04:49:02] m1dnight_: has joined #elixir-lang
[04:55:16] m1dnight_: Remote host closed the connection
[05:08:35] m1dnight_: has joined #elixir-lang
[22:04:21] m1dnight_: Read error: Connection reset by peer
[22:13:10] m1dnight_: has joined #elixir-lang
[22:34:27] m1dnight_: Read error: Connection reset by peer
[22:43:11] m1dnight_: has joined #elixir-lang
[23:04:38] m1dnight_: Read error: Connection reset by peer
[23:13:23] m1dnight_: has joined #elixir-lang
[23:34:37] m1dnight_: Read error: Connection reset by peer
[23:36:45] m1dnight_: has joined #elixir-lang

2019-09-04

[10:03:59] m1dnight_: Ping timeout: 244 seconds
[10:06:28] m1dnight_: has joined #elixir-lang
[20:49:15] m1dnight_: Ping timeout: 258 seconds
[20:51:36] m1dnight_: has joined #elixir-lang
[20:53:58] m1dnight_: Read error: Connection reset by peer
[20:56:41] m1dnight_: has joined #elixir-lang
[21:32:57] m1dnight_: Ping timeout: 245 seconds
[21:41:46] m1dnight_: has joined #elixir-lang
[21:48:40] m1dnight_: Ping timeout: 258 seconds
[21:51:50] m1dnight_: has joined #elixir-lang
[22:04:06] m1dnight_: Read error: Connection reset by peer
[22:06:07] m1dnight_: has joined #elixir-lang

2019-09-03

[12:11:30] m1dnight_: has joined #elixir-lang

2019-08-30

[18:14:38] m1dnight_: Ping timeout: 245 seconds
[19:02:34] m1dnight_: has joined #elixir-lang
[19:17:58] m1dnight_: Ping timeout: 245 seconds

2019-08-22

[00:56:00] m1dnight_: *.net *.split
[01:13:58] m1dnight_: has joined #elixir-lang
[08:17:40] m1dnight_: Quit: WeeChat 2.4
[08:19:16] m1dnight_: has joined #elixir-lang

2019-08-19

[01:30:34] m1dnight_: Ping timeout: 258 seconds
[01:34:01] m1dnight_: has joined #elixir-lang
[22:48:46] m1dnight_: Read error: Connection reset by peer
[22:51:07] m1dnight_: has joined #elixir-lang

2019-08-13

[10:59:06] m1dnight_: What is the rationale behind *not* throwing an error when you compare two different types in Erlang? (http://erlang.org/doc/reference_manual/expressions.html)
[11:18:05] m1dnight_: I get that you can sort any collection, because Erlang/Elixir allows you to create heterogenous collections. But I don't think that you should be able to sort them , just to sort them, no?
[11:18:18] m1dnight_: I mean, what is the meaning of Enum.sort([1, "foo", {1,2}]) even?
[11:18:34] m1dnight_: I think it might be just as well that it would throw an error?
[11:19:30] m1dnight_: Something makes me feel icky if I think that some user code would rely on the explicit ordering that is defined in the spec (number < atom < reference < fun < port < pid < tuple < map < nil < list < bit string)
[11:22:16] m1dnight_: But what makes it "fine"?
[11:22:28] m1dnight_: Why should a fun be smaller than a port, for example.
[11:22:39] m1dnight_: I'm not picking a fight here or something, btw. Just really curious.
[11:23:36] m1dnight_: because it's lexicographically defined, and every programming language out there has some form of strings/chars and they adhere to the same order
[11:24:40] m1dnight_: fair enough
[11:25:09] m1dnight_: So the requirement was a total order across all types and instances of all types
[11:25:24] m1dnight_: And a usecase of that total order is ETs indices.
[11:25:28] m1dnight_: I'll need to read up on that :)
[11:25:36] m1dnight_: How so, nox?
[11:27:26] m1dnight_: I'd expect 5.2 > 5 and 5 > 4.9
[11:27:30] m1dnight_: ACTION tries some repls
[11:28:16] m1dnight_: Yeah, it's "correct" now. It would be super weird to make that order different.
[11:29:02] m1dnight_: iex(3)> 1 > 1.0
[11:29:05] m1dnight_: iex(4)> 1 < 1.0
[11:29:17] m1dnight_: oh no wait, that makes total sense nvm.
[11:30:09] m1dnight_: Well yeah, I see your point there. But then again, if your application logic relies on the implementation of that function you are breaking encapsulation imo
[11:30:24] m1dnight_: So yeah, that's really a tough thing to decide.
[11:30:42] m1dnight_: But id say that the implementation now is the lesser of two "evils"
[11:34:21] m1dnight_: Weakly typed languages that coerce are the devil.
[11:35:13] m1dnight_: ericmj: Exactly. I was reasoning under the assumption that nobody in his/her right mind would actually need to something like sorting heterogenous lists, but I guess I was wrong about that.

2019-08-12

[21:49:23] m1dnight_: Ping timeout: 248 seconds
[21:51:48] m1dnight_: has joined #elixir-lang

2019-08-07

[08:51:03] m1dnight_: I have three parsecs written in Nimble. One for a string of type X, Y, and Z.
[08:51:19] m1dnight_: What is the most efficient way to try any of them and see which one works?
[08:51:52] m1dnight_: I think that, because they do not attach meta-data, I should go to "regular" elixir and try them all, such that if one succeeds I can turn it into a struct, right?
[08:52:07] m1dnight_: https://exbin.call-cc.be/ChyackPoundage <- my actual parsers
[09:01:44] m1dnight_: https://exbin.call-cc.be/UnscramblesRetirements <- something like this is how I guess I could do it.

2019-07-27

[09:25:13] m1dnight_: Quit: WeeChat 2.4
[09:30:16] m1dnight_: has joined #elixir-lang
[09:33:52] m1dnight_: Client Quit
[09:38:13] m1dnight_: has joined #elixir-lang

2019-07-26

[15:27:08] m1dnight_: bitwalker: can i bother you about libgraph?
[15:27:13] m1dnight_: (Quick question)
[15:28:09] m1dnight_: Cool! Well, I'm wondering why the map/2 function does not return a graph, but instead returns a list of nodes.
[15:28:34] m1dnight_: I expected map/2 to have the type Graph -> (Node -> Node) -> Graph
[15:28:52] m1dnight_: Or Graph a -> (a -> b) -> Graph b in haskelly notation
[15:29:01] m1dnight_: But now it's Graph a -> (a -> b) -> [b] ?
[15:29:44] m1dnight_: I really need something like that, so maybe this could be something I could contribute? (given enough time because it seems like a non-trivial project to dive in)
[15:43:37] m1dnight_: I'll have a look at it, see if I can come up with something :D
[15:43:39] m1dnight_: thanks for your time

2019-07-25

[07:27:42] m1dnight_: Quit: WeeChat 2.4
[07:36:15] m1dnight_: has joined #elixir-lang

2019-07-15

[07:49:12] m1dnight_: Ping timeout: 245 seconds
[08:22:57] m1dnight_: has joined #elixir-lang

2019-07-09

[06:06:43] m1dnight_: Ping timeout: 245 seconds
[08:50:32] m1dnight_: has joined #elixir-lang

2019-07-05

[11:52:57] m1dnight_: Ping timeout: 245 seconds

2019-07-03

[13:59:36] m1dnight_: What's the difference between backoff and backpressure in the context of broadway?(https://hexdocs.pm/broadway/Broadway.html)
[13:59:40] m1dnight_: It's mentioned as a todo.
[13:59:53] m1dnight_: I'd say backoff is one approach to tell producers to, well, back off, and thus get backpressure?
[14:14:03] m1dnight_: So backoff could be "give data" x 100, and then the producer says "backoff", like that?
[14:14:20] m1dnight_: Seems like you can apply it to failed computations, getting data, ..
[14:14:23] m1dnight_: but gotcha, thanks

2019-07-02

[16:45:28] m1dnight_: Ping timeout: 272 seconds
[16:48:11] m1dnight_: has joined #elixir-lang

2019-07-01

[19:29:21] m1dnight_: Quit: WeeChat 2.4
[19:34:50] m1dnight_: has joined #elixir-lang

2019-06-24

[14:38:40] m1dnight_: has joined #elixir-lang
[14:44:10] m1dnight_: Ping timeout: 258 seconds
[14:49:00] m1dnight_: has joined #elixir-lang

2019-06-23

[11:47:21] m1dnight_: Ping timeout: 244 seconds

2019-06-21

[13:04:53] m1dnight_: Why did people choose pull-based semantics for genstage, instead of pull based?
[13:05:10] m1dnight_: I get that pull-based offers implicit backpressure, but that's about the only reason I can come pu with.
[13:30:13] m1dnight_: I took it to slack for further discussion. Yes, that could have been the point, but I don't know why they made the decision. Apparently that is. Explicit backpressure is difficult to do, and runs into problems with fundamental distribution semantics.
[13:30:19] m1dnight_: That's the long and short of it I guess
[13:32:01] m1dnight_: Yeah it kind of is.
[13:32:19] m1dnight_: Well, the reason im figuring this out is because I built a rudimentary streaming framework that's push based. I wanted to see if I can add backpressure.
[13:32:21] m1dnight_: But it's going to be hard.
[13:46:16] m1dnight_: I'm not an expert on TCP, but isn't tcp synchronous?
[13:46:45] m1dnight_: okay, makes sense

2019-06-18

[07:49:48] m1dnight_: Quit: WeeChat 2.4
[07:54:02] m1dnight_: has joined #elixir-lang
[07:54:04] m1dnight_: Client Quit
[09:27:33] m1dnight_: has joined #elixir-lang
[09:27:46] m1dnight_: Client Quit
[09:42:24] m1dnight_: has joined #elixir-lang
[09:42:25] m1dnight_: Client Quit
[09:44:29] m1dnight_: has joined #elixir-lang
[09:45:13] m1dnight_: Client Quit
[09:45:57] m1dnight_: has joined #elixir-lang
[09:50:34] m1dnight_: Is the only reason Flow is not distributed because of supervision?
[09:50:54] m1dnight_: I mean, if its built on top of genstage, it's fairly easy to distribute it over nodes, no?
[09:51:15] m1dnight_: Or are there specific semantics that differ compared to broadway ?
[10:52:03] m1dnight_: Because the b variable is not bound in your left argument of |>
[10:52:15] m1dnight_: It's probably bound in `whs_query`.
[10:52:24] m1dnight_: no, scratch that. Im wrong.

2019-06-17

[11:11:17] m1dnight_: Quit: WeeChat 2.4
[11:11:36] m1dnight_: has joined #elixir-lang
[11:11:50] m1dnight_: Remote host closed the connection
[11:12:01] m1dnight_: has joined #elixir-lang
[14:19:03] m1dnight_: Quit: WeeChat 2.4
[14:19:20] m1dnight_: has joined #elixir-lang
[14:19:48] m1dnight_: Client Quit
[14:20:08] m1dnight_: has joined #elixir-lang
[14:20:10] m1dnight_: Client Quit
[14:21:47] m1dnight_: has joined #elixir-lang
[14:21:48] m1dnight_: Read error: Connection reset by peer
[14:22:24] m1dnight_: has joined #elixir-lang
[14:23:12] m1dnight_: Remote host closed the connection
[14:26:50] m1dnight_: has joined #elixir-lang
[14:26:57] m1dnight_: Client Quit
[14:27:20] m1dnight_: has joined #elixir-lang
[14:28:10] m1dnight_: Read error: Connection reset by peer
[14:28:21] m1dnight_: has joined #elixir-lang
[14:48:45] m1dnight_: Quit: WeeChat 2.4
[15:05:41] m1dnight_: has joined #elixir-lang
[15:06:39] m1dnight_: Client Quit
[15:08:30] m1dnight_: has joined #elixir-lang
[15:17:21] m1dnight_: Quit: WeeChat 2.4
[17:39:23] m1dnight_: has joined #elixir-lang

2019-06-16

[16:28:47] m1dnight_: Ping timeout: 245 seconds
[16:51:58] m1dnight_: has joined #elixir-lang
[16:52:10] m1dnight_: Client Quit
[16:52:28] m1dnight_: has joined #elixir-lang
[17:11:42] m1dnight_: Quit: WeeChat 2.4
[17:13:31] m1dnight_: has joined #elixir-lang
[19:54:02] m1dnight_: Quit: WeeChat 2.4
[19:54:37] m1dnight_: has joined #elixir-lang

2019-06-14

[09:12:52] m1dnight_: Ping timeout: 246 seconds
[09:25:38] m1dnight_: has joined #elixir-lang
[10:33:32] m1dnight_: Quit: WeeChat 2.4
[10:41:43] m1dnight_: has joined #elixir-lang
[11:44:56] m1dnight_: Quit: WeeChat 2.4
[20:11:36] m1dnight_: has joined #elixir-lang

2019-06-13

[08:23:31] m1dnight_: has joined #elixir-lang

2019-06-12

[10:33:41] m1dnight_: Nicd-: that blog if yours is hella fast :) nice
[10:35:32] m1dnight_: Ah, if you have some PRs i can maybe lend q ‚úč
[10:37:56] m1dnight_: And by pr's i mean issues :p i always confuse the two.
[11:06:27] m1dnight_: Phoenix doesnt need a webserver
[11:06:35] m1dnight_: And phoenix can do ssl.
[11:06:50] m1dnight_: I dont see a problem?
[11:13:09] m1dnight_: I prefer to have apache do my ssl amd whatnot. Phoenix only serves http for me
[11:13:20] m1dnight_: One place to manage your certs, domains, etc.
[11:13:40] m1dnight_: (apache, nginx, whatever your preference is)
[11:13:55] m1dnight_: serafeim: https://blog.nytsoi.net/
[11:15:49] m1dnight_: What are atomics? Never heard of it.
[11:16:22] m1dnight_: Ah found it on erldocs, wilk give it a read
[21:23:18] m1dnight_: Ping timeout: 272 seconds

2019-06-09

[20:20:23] m1dnight_: Because they are horrible to work with. They have a horrible api, do magic stuff and take js from all over the place.
[20:21:04] m1dnight_: I have a masters degree and dont consider myself dumb, yet I fail to grasp how it all works :p
[20:21:35] m1dnight_: It should work just like hex. Simple, elegant, and seemless.

2019-06-08

[14:52:22] m1dnight_: Ping timeout: 272 seconds
[14:58:02] m1dnight_: has joined #elixir-lang

2019-05-29

[08:32:39] m1dnight_: Hey guys, I'm going through this article (http://blog.plataformatec.com.br/2015/05/introducing-reducees/) and I'm a bit confused with a statement made in it. In particular:
[08:33:04] m1dnight_: "Reduces provide many advantages: ... It opens the door to parallelism as its operations are no longer serial (in contrast to iterators) "
[08:33:14] m1dnight_: Given that reducers api, I really don't so how you can easily parallelize it?
[09:18:14] m1dnight_: that would mean y ou can do parallelism in one step of the pipeline, but not between multiple steps, I guess
[09:18:25] m1dnight_: I'll read some clojure articles maybe

2019-05-28

[10:16:34] m1dnight_: Ping timeout: 272 seconds
[10:18:11] m1dnight_: has joined #elixir-lang
[13:41:03] m1dnight_: Where is the implementation for reduce for streams?
[14:07:28] m1dnight_: I found most of them here: https://github.com/elixir-lang/elixir/blob/v1.0.5/lib/elixir/lib/enum.ex#L2230 so I expected them to be there too. I'll look in the streams module perhaps
[14:07:58] m1dnight_: https://github.com/elixir-lang/elixir/blob/v1.8.2/lib/elixir/lib/stream.ex#L1559 got it.
[14:08:14] m1dnight_: Given that there is a List and a Map module, why are the defimpl Enumerable not there then?
[14:08:29] m1dnight_: (I'm just curious, not critisizing)
[15:20:04] m1dnight_: Fieuw, I was going through the implementation of Streams. What a complex piece of code.
[15:20:27] m1dnight_: This is where a step-through debugger might help grasping the code.

2019-05-27

[06:35:34] m1dnight_: Quit: WeeChat 2.4
[06:43:51] m1dnight_: has joined #elixir-lang

2019-05-25

[09:29:05] m1dnight_: Quit: WeeChat 2.4
[09:34:24] m1dnight_: has joined #elixir-lang

2019-05-24

[18:14:19] m1dnight_: Quit: WeeChat 2.4
[21:17:47] m1dnight_: has joined #elixir-lang

2019-05-22

[19:14:58] m1dnight_: okay guys, I just submitted a paper to middleware. Im going to procrastinate like crazy. Give me a PR to fix!
[19:15:06] m1dnight_: or, otherwise, hey all
[19:19:38] m1dnight_: damn, no issues on elixir :p
[19:19:41] m1dnight_: what is this for perfect language
[19:27:19] m1dnight_: I've been hacking together a website with a remote repl to dockers running iex
[19:27:24] m1dnight_: but im kind of sick of that
[19:27:38] m1dnight_: I really want to contribute to some open source
[19:27:51] m1dnight_: but i feeltoo dump for most of them

2019-05-21

[11:49:12] m1dnight_: use RunnerWeb, :view
[11:49:14] m1dnight_: alias RunnerWeb.ProgramView
[11:49:16] m1dnight_: def render("index.json", %{programs: programs}) do
[11:49:18] m1dnight_: %{data: render_many(programs, ProgramView, "program.json")}
[11:49:22] m1dnight_: def render("show.json", %{program: program}) do
[11:49:24] m1dnight_: IO.inspect program
[11:49:26] m1dnight_: %{data: render_one(program, ProgramView, "program.json")}
[11:49:31] m1dnight_: def render("program.json", %{program: program}) do
[11:49:32] m1dnight_: IO.inspect program
[11:49:34] m1dnight_: inspect(program)
[11:49:40] m1dnight_: https://exbin.call-cc.be/ExpeditesBroils
[11:49:44] m1dnight_: So well, that link contains that text... :p
[11:50:54] m1dnight_: When you call "render_one", I assumed it would just be a functioncall to render("program.json") but a lot of data i added around it
[11:51:15] m1dnight_: My idea would have been to change those functions from program to result, because my api expects a program, and returns a result
[11:51:29] m1dnight_: I don't need another resultcontroller and all that jazz. just a response