13:26 <TwoNotes> Am I correct that 'a = b' implies "cloning the value" when b is a U32, but it is "create an alias" when b is a class object reference?

13:26 <TwoNotes> I think this involves the difference between 'let' and 'var'

13:45 <jemc> TwoNotes: from the perspective of the type system, the `=` is always aliasing the right hand side

13:45 <jemc> from the perspective of the implemetation,

13:46 <TwoNotes> But if a is 'var a: U32', don't I end up with a clone of the value?

13:46 <jemc> almost all objects in Pony are represented as pointers to an object, but the numeric primitives are a bit of a special case

13:47 <jemc> in the implementation, `=` is always just copying the value on the right hand side

13:47 <TwoNotes> Ok, so for anything not a numeric primitive, I have to use a .clone() function of some kind to really make a copy.

13:47 <jemc> most of the time, that means copying a pointer, so its an alias in the traditional sense

13:47 <jemc> but for numeric primitives, its represented as the actual value, so you're just copying the bytes of the value and not the pointer

13:48 <TwoNotes> I am trying to write some words on how a 'reference' is not like a 'pointer' and how 'copying' is not the same as "creating another alias'.

13:48 <jemc> well, what does it really mean to make a copy of a number?

13:48 <jemc> vs aliasing a number? what is the semantic difference?

13:49 <TwoNotes> Once it has been copied, it can be modified without affecting the original

13:49 <jemc> numbers can never be modified - they're always `val` - immutable

13:49 <TwoNotes> n = n + 1

13:50 <jemc> you're reassigning `n` to have a new value - you haven't modified the old value

13:50 <jemc> note that you can only do that with a `var`, not a `let`

13:50 <jemc> same is true if you're talking about a `val` object

13:50 <TwoNotes> Yes, I think of a 'let' as more of a 'compiler temporary value that has been assigned a name for convenience'

13:51 <TwoNotes> Ok, so conceptually, n=n+1 could be implemented as fetching the contents of the currefent 'n' reference, adding 1 to it, putting this somewhere new, and adjusting 'n' to refer to this new place.

13:52 <TwoNotes> If n==5 to start, by doing n=n+1 I have not changed the meaning of 5.

13:53 <jemc> right, but numerics aren't a special case in this way - the same would be true if you were using a `collections/persistent` `Map`

13:54 <TwoNotes> I am trying to describe this in a way that makes sense to programmers coming from other languages, who are not compiler theoreticians. *I* understand it becuase I have worked on a lot of compiler implementations and am used to such subtleties.

13:54 <jemc> the fact that numerics are implemented a bit differently from objects doesn't have an impact on the user (except when using FFI), because the ref cap system makes all `val` objects work this same way

13:55 <jemc> so I wouldn't think that you need to explain an implementation difference between numerics and non-numerics (except in an FFI tutorial)

13:55 <TwoNotes> If I had 'var n: U32 val = 5' then I would not be able to do n=n+1, right?

13:56 <jemc> no, you can do that - in fact it's the same as `var n: U32 = 5; n = n + 1`

13:56 <jemc> because numerics can only be created as `val`

13:57 <TwoNotes> I thought a 'val' reference can not be modified by any actor

13:57 <TwoNotes> 'var n: U32' is a 'ref', isn't it?

13:58 <jemc> "modified" is a fuzzy term in this context, and should probably be avoided, because we have two separate concepts that are important to distinguish: "reassignment" and "mutation"

13:58 <TwoNotes> ahhh

13:58 <jemc> TwoNotes: no, anywhere you see `U32` it is always `U32 val`

13:59 <jemc> so `var` vs `let` deals with reassignment, and mutation deals with `val` vs other ref caps

14:00 <TwoNotes> I got that now. ok. But now the difference between 'reassignment' and 'creating an alias'...

14:01 <jemc> not much of a difference - from the type system's point of view, "assignment" always creates an alias

14:01 <jemc> but there are a few wrinkles that make this a little more subtle

14:01 <TwoNotes> Doing a 'let' always creates an alias, but it does not do reassignment.

14:02 <TwoNotes> You can not take an 'addressof' of a 'let', because there is no 'there' there. It is not necessarily stored anywhere

14:02 <jemc> one is that some types alias as themselves with no problems (ref, box, val, tag), because they have no uniqueness restrictions, so aliasing them doesn't matter much, which you can't alias the other ref caps (iso, trn) as themselves since they have a uniqueness restriction

14:03 <jemc> I wouldn't quite describe it that way

14:03 <SeanTAllen> let and var are about name bindings

14:04 <jemc> the compiler doesn't let you take an `addressof` of a `let`, because the only reason to do this is for FFI, and doing so would make it possible for the FFI function you call to reassign the `let`, which is not allowed

14:05 <jemc> that is, passing the address of a local variable is the common C way of allowing the function to change your local variable, and Pony allows that only for `var`, not `let`

14:05 <TwoNotes> ok

14:06 <TwoNotes> I did a lot of work on the BLISS language 40 years ago, and the distinction between a 'name' and a 'value' was very explicit there.

14:08 <jemc> TwoNotes: I think you may be overthinking `let` vs `var` - it's pretty much exactly the same as these keywords are in javascript and other languages

14:11 <TwoNotes> So a 'hat' type is a reference with no alias yet, correct?

14:12 <jemc> the `hat` is a way to cancel out the aliasing - it's sort of like an anti-alias - the alias of A^ is A, and the alias of A is A!

14:13 <jemc> but yes, the "hat" indicates that value is ephemeral and is not bound to any name

14:14 <TwoNotes> So the value of a 'consumed iso' is iso^ ?

14:14 <jemc> yep

14:14 <ohir> jemc: https://bluishcoder.co.nz/2016/05/04/bang-hat-and-arrow-in-pony.html

14:15 <ohir> jemc: I wonder if it is enough good as a reference (in your opinion)

14:16 <jemc> I haven't read through that post yet, but I know sylvan read it and liked it

14:16 <ohir> jemc: thx, thats enough

14:16 <jemc> from a quick scan, it looks quite nice to me

14:17 <TwoNotes> I found it quite useful

20:08 <nyarumes> Hey, why our http server so slow by default?

20:08 <nyarumes> 49.75

20:08 <nyarumes> r/s

20:08 <nyarumes> from wrk tool :)

21:27 <SeanTAllen> the http server was designed as a proof of concept. nyarumes. no one should be using that for anything other than playing around.

21:28 <SeanTAllen> the only thing it should be used for is learning how to write something like it, not for actual performance of it.

21:46 <TwoNotes> Important in servers that give out volumes of data is to minimize copying. Peek carefully into the Array and String classes for 'clone' operations.

23:16 <nyarumes> TwoNotes: it is just Hello World :D

23:17 <nyarumes> SeanTAllen: but 49 req/s it is O_o

23:17 <nyarumes> Go give without optimisations - 79k req/s