The Nineteenth Byte

quartata

3:02 AM

Ooh, another one. Uh ... the ability to alter any coefficients of friction at will during sporting events.

I think this is probably my favorite xkcd

I always lose it at "a finite but arbitrarily large number of wishes"

Helka Homba

Making Octo 3

►

^ I'd like one of these in my yard (and I'd like a yard while I'm at it)

Downgoat

3:24 AM

how do i upates my github fork

@Quill where is adynata interpretetiting code

quartata

@Downgoat I don't think you can. I always just destroy and refork.

Downgoat

@quartata ._.

nvm, git pull upstream works

@QPaysTaxes :D

:(

@QPaysTaxes OH YES, BRB DOING THAT

(but in a new file)

what does this part do?:

if sys.version_info[0] < 3:

also, does r"\n" match a literal newline or \n?

ok

Kenny Lau

3:47 AM

@FryAmTheEggman s+:R"O.*<|>.*O"0Q:R"O.*\^|v.*O"0CQ

A solution to a challenge

Downgoat

@QPaysTaxes what does this bit of code do (in the escape function): lambda s: escapes.get(s.group(0), s.group(1))

but what does escapes.get(s.group(0), s.group(1)) this bit do?

Quill

@Downgoat wat

The very shitty language I am/was working on

lately I've got a massive amount of issues being opened in my SE related code, so I've had no time to whore it around the room

yeah, like userscripts, chat bots, etc

else:
    str = str
    input = input

seems a little redundant <_<

Mars Ultor

4:06 AM

But

wait a sec, it is

Downgoat

4:20 AM

@QPaysTaxes what license is Concaten under?

orlp

last challenge was 10 hours ago

what is this people

get to work!

more challenges!

NO EXCUSES

Downgoat

@orlp but im a goat, i am busy eating tin cans

orlp

@Downgoat since your goat is upside down you must be from australia - are you gary?

Downgoat

@orlp ? I am from california

Quill

@orlp what about south america and africa

Mars Ultor

4:30 AM

> valfonria

Quill

it's next door to narnia

Downgoat

@Quill south america and africa touch the equator so it's not completely on the southern ehemisipher

Quill

....

Downgoat

i make good commit messages

Quill

I think I might start hanging out in Discord a bit more

Nathan Merrill

4:32 AM

hey, I'm debating making the clone() method in my language take an integer parameter that determines the number of levels deep

Downgoat

@Quill Discord?

Nathan Merrill

clone(list, 1) would copy the structure, but clone(list, 2) would copy the objects in the list as well

Downgoat

@NathanMerrill it should completely clone an object. An integer parameter doesn't make sense to me

Nathan Merrill

what do you mean by "completely"

should cloning a list clone the objects as well?

Mars Ultor

@NathanMerrill recursive, infinite levels

Nathan Merrill

4:34 AM

that's not what you want in most cases

Downgoat

why not?

Nathan Merrill

copying a new structure without cloning the objects

for example

Downgoat

if I wanted to clone a class, which has a property which is equal to another class, and so on, would it just truncate properties that aren't primitives?

Nathan Merrill

List<List<Object>>

lets say I wanted to clone the above, but not the actual objects

I could do clone(list2d, 2)

Downgoat

@NathanMerrill I guess if you'd think an integer parameter would be helpful, it should be optional.

Quill

4:36 AM

vimeo.com/121107493

good coding music

Downgoat

@Quill thanks for not being a rickroll

Mars Ultor

Depends

Nathan Merrill

@Downgoat of course, set to 1

Mars Ultor

Normally clone() implementations do a shallow (1-depth) clone

Downgoat

Question about cheddar: if a variable is operated upon, should it loose its reference?

Mars Ultor

4:38 AM

@Downgoat ?

Quill

you don't really need explicit references if you're not making a stack based language or one with limited space

Mars Ultor

@Downgoat halp do you know any JS application things other than Ace Editor?

Quill

application things?

Downgoat

basically if I have a variable and I reference it (e.g. by calling avocad), it is put on the call stack, when it is put on the call stack, it get's a special property saying where it originated from (the variable name), if an operator modifies the item, should it loose that special property?

@MarsUltor what is wrong with ace?

Mars Ultor

Nothing, just that it's only one thing

Nathan Merrill

4:40 AM

another question. I want to make a constant modifier for my class, which basically ensures that any modifying function clones the object before modifying it

Quill

@Downgoat the value has to get reassigned somewhere

Nathan Merrill

but what if I have a constant Queue

and I call "pop"

Downgoat

@MarsUltor codemirror maybe?

Nathan Merrill

what gets returned?

Downgoat

though ace is the best by a longshot

Mars Ultor

4:41 AM

I mean things other than a text editor

Downgoat

@Quill what do you mean by that?

Quill

var a = 4;
a + 1 // the value is returned and goes nowhere
a = a + 2; // the value is reassigned

Downgoat

@MarsUltor like tinymce

Nathan Merrill

either 1. I don't allow returning values on functions that modify for constant classes, 2. I return a tuple, or 3. I return the new value, but don't have a reference to the new queue

Downgoat

@Quill yeah, so the behavior of ++ would get the reference and update it, but after an operator is used on a variable, it should loose it's refernce?

e.g. (a++)++ shouldn't work?

Quill

4:43 AM

sorry, see update

255

A: Declare a Const Array

Yes, but you need to declare it readonly instead of const: public static readonly string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" }; The reason is that const can only be applied to a field whose value is known at compile-time. The array initializer you've shown is not a constant ...

@NathanMerrill ^ I like how C# does it

Nathan Merrill

my definition of constant is a bit different

maybe I'll name it differently

Integer is constant

because if I do a = 1, b = a, a++, b returns 1

Mars Ultor

That's C#'s struct

returns a new instance every time, except for integer decrement/increment

Nathan Merrill

except?

why?

Mars Ultor

I mean

uh wait

ints are primitives

Quill

lol

Mars Ultor

4:48 AM

structs do return a new instance every time though

probably what you want for constant non-primitives

Nathan Merrill

anyways, what if a struct has a function that modifies itself and returns a value?

is the newly-modified struct inaccessible?

Mars Ultor

Pretty sure structs can't change their values

any operator + assignement (e.g. +=) is actually a create + set

Nathan Merrill

I can't find any documentation on that

New Main Posts

0

Q: Output the alphabet using the alphabet

The title is pretty self-explanatory, isn't it? Your task is to output the alphabet (the string "abcdefghijklmnopqrstuvwxyz") to STDOUT, using each and every letter of the lowercase alphabet in your program once and only once. Rules: Only standard letters of the alphabet from ASCII count as l...

orlp

@KennyLau cat is not a programming language, but turing completeness is not required

Kenny Lau

4:55 AM

it is required

Whoops

no its not

My bad

43

A: What are programming languages?

My previous answer was criticised for not drawing a line in a sand, so following some discussion on chat I propose a line. Executive Summary A purported programming language should be accepted as such if and only if it is capable of addition of natural numbers and primality testing of natural n...

Mars Ultor

It's just that any assignment deep copies

Nathan Merrill

4:55 AM

hmmm...it appears that assignment copies

not modification

for structs

Mars Ultor

yeah

Kenny Lau

@orlp well, use your lang to demonstrate that 17 is a prime

Mars Ultor

makes a lot more sense

orlp

1 min ago, by orlp

@KennyLau cat is not a programming language, but turing completeness is not required

Nathan Merrill

therefore, if you have a function that modifies the struct

it'll modify it, just like any other function

Mars Ultor

4:56 AM

@orlp Primality testing is though

Plus basic arithmetic

orlp

which part of "cat is not a programming language" is unclear?

Quill

meow

Nathan Merrill

is there a term for "copy on assignment"?

Helka Homba

@orlp @KennyLau It's a poor question anyway. Not worth arguing about

orlp

@NathanMerrill cow; copy on write

or do you mean the opposite?

@HelkaHomba I think it's an interesting challenge for python for example

Nathan Merrill

4:58 AM

I mean that a = MyObj(), b = a, b is a cloned object

Quill

orlp

@NathanMerrill value semantics

as opposed to reference semantics

Python uses reference semantics

C uses value semantics

Nathan Merrill

right, but if it is modifier for a class, what would that be?

orlp

could you rephrase?

'modifier for a class'?

Downgoat

@Quill @cat iz overflowing r bufferz? D:

Nathan Merrill

5:00 AM

aka, by default, everything is copy by reference, but you can declare certain classes to by copy by value

(technically, variables will still be references, but it'll call the clone method before copying)

orlp

@NathanMerrill you declare those classes to have value semantics

is this for a programming language your designing?

Nathan Merrill

yes

orlp

I can tell you that this will probably cause a lot of confusion

and is probably not the way to go

Nathan Merrill

hmmm? Why do you think so?

for example, Integers and Strings work this way.

orlp

because now when I see a = b somewhere I need to know what a and b are

@NathanMerrill in Python?

or

Nathan Merrill

5:02 AM

yes

orlp

because that's not how they work

they are immutable

but still have reference semantics

Nathan Merrill

functionally, they are identical. a = 4; b = a; a++

b is still 4

same thing with strings

orlp

@NathanMerrill python doesn't have a++

Nathan Merrill

oh right

a += 1

orlp

that's shorthand for a = a + 1

which makes a new object

so b is left unchanged because a is now a reference to a new object

Nathan Merrill

5:04 AM

right, and that's literally what I'm doing

orlp

then you should say that integer and string are immutable

Downgoat

@orlp how are strings immutable if you can do a = "foo"; a = 123?

orlp

@Downgoat because a is a nametag

Downgoat

oh, so the value within is the immutable thing?

orlp

when I write a = "foo", now a is a name for some literal string

Mars Ultor

5:05 AM

Yes

orlp

if I now do b = a, then id(b) = id(a)

Nathan Merrill

whether or not the copy happens on assignment or on modification makes little difference IMO

orlp

@NathanMerrill the thing is

in Python

= never copies

Nathan Merrill

right, just that a+1 returns a new reference

orlp

a = ... means "a is now a name for ..."

Mars Ultor

5:07 AM

var a = 'foo', b = a, a += 'bar'
a
"foobar"
b
"foo"

Kenny Lau

@orlp hard thing doing it in python

Mars Ultor

If strings were mutable, "foo" would become "foobar" in both variables since the actual string changes

Nathan Merrill

python does copy on modification

orlp

@MarsUltor again, a += ... is shorthand for a = a + ..., and never modifies whatever a pointed to

@NathanMerrill it does not

Nathan Merrill

aka, a + 1 creates a new variable with the value of the two added together

orlp

5:08 AM

it creates a new value

then a points to that value

Nathan Merrill

its an object

right

a new object is being made

Downgoat

@El'endiaStarman have you gotten to assignment in Pytek?

orlp

yes

Nathan Merrill

therefore, maybe "copy" is the wrong word, but it is effectively copy on modification

orlp

no, it's not a copy on modification

a copy implies a new memory location

Nathan Merrill

5:09 AM

well, if there is a new object

there's a new memory location

orlp

then it means the copy already happened

not 'on modification'

keep in mind

strings and integers are never modified

5 + 3 modifies neither 5 nor 3

Nathan Merrill

what actually happens in the backend is irrelevant

orlp

it's just a function that returns a new value based on 5 and 3

Nathan Merrill

a + 1 could copy a, then modify the copy to be plus 1

orlp

if a = [1, 5, 2], then a[1] = 31 means a was modified

@NathanMerrill but that's a perversion, that's not how it works

modification of an object is well-defined in Python

class A: pass; a = A()

a.x = 5 <-- this is modification

Nathan Merrill

5:13 AM

I know that it isn't actually copying

Kenny Lau

I've concluded that it is impossible in python

orlp

@KennyLau what is?

Kenny Lau

that challenge

Nathan Merrill

anyways, are there functional differences between "clone on assignment" vs "clone on modification"

orlp

@NathanMerrill yes

Nathan Merrill

5:14 AM

aka, pass by value vs immutable

@orlp beyond what happens behind the scenes?

orlp

clone on modification is not immutable

get that out of your head

copy on write is well-defined, and something different

for example, some C++ implementations use copy-on-write for strings

Nathan Merrill

I know what happens is different, but the two are functionally identical

orlp

they are not

let's say I do this in Python

a = [1, 2, 3]
b = a[:] # copy
b[1] = 42

now a is [1, 2, 3], and b is [1, 42, 3]

Nathan Merrill

right

orlp

normally, the data inside a is copied on the line that says copy

but that's not needed, until b is modified

now some (implementations of) languages, employ copy on write

that means that the copy doesn't actually happen until it's necessary

so in the example above, no copy would happen until b[1] = 42

Copy-on-write

Copy-on-write (sometimes referred to as "COW"), sometimes referred to as implicit sharing, is an optimization strategy used in computer programming. Copy-on-write stems from the understanding that when multiple separate tasks use initially identical copies of some information (i.e., data stored in computer memory or disk storage), treating it as local data, each task working on its own "copy of the data", that they may occasionally need to modify, then it is not necessary to immediately create separate copies of that information for each task. Instead they can all be given pointers to the same...

Nathan Merrill

5:17 AM

right, but lets say you can't see what happens behind the scenes

they are functionally identical

orlp

no they are not

a + 1 doesn't copy anything

get that out of your head

Nathan Merrill

I know it doesn't, but if it did, you couldn't tell the difference

seriously, lets say that integers were copy on write. give me two sections of python code that would execute differently

meaning, the return value is different

orlp

integers can't be copy on write

since you can't write them

Nathan Merrill

they could be, if I wrote my own implementation of python

orlp

how would you write integers?

Nathan Merrill

5:21 AM

class MyInt:
    def __init__(self, val):
        self.val = val

now, lets say there are two possible add functions

orlp

add is not a copy operation

can we get over this?

Nathan Merrill

def add(self, other):
     return MyInt(self.val + other)

def add(self, other):
      new_int = MyInt(self.val)
      new_int.val += other
      return new_int

while the first is clearly optimal

orlp

they are identical

but what about that?

neither are copy operations or have any relevance to copy on write

Nathan Merrill

I'm using the new_int as a copy operation

Mars Ultor

A constructor pretty much creates a copy

orlp

5:24 AM

new_int = MyInt(self.val) here you've already copied

so neither is copy on write

Nathan Merrill

right, I copy and write

I don't know how that isn't "copy on write"

orlp

copy on write means that no copy happens until a write happens

Nathan Merrill

do you write to the old copy?

because I'm clearly writing to the new copy

orlp

@NathanMerrill copy on write is rather complicated

class COWList:
    def __init__(self, l):
        self.l = l

    def append(self, val):
        self.l.append(val)

    def set_item(self, idx, val):
        self.l[idx] = val

    def get_item(self, idx):
        return self.l[idx]

    def clone(self):
        return COWList(self.l[:])

consider that

this is not a proper copy-on-write list

because the clone immediately copies

instead of doing it when a write happens (append or set_item)

Mars Ultor

you'd need a reference to the original list, then instantiate that on the first (and only the first) operation, i think

Nathan Merrill

5:36 AM

sure, but if you called clone right before the two functions, then then your list would be copy-on-write

orlp

@NathanMerrill you have a fundamental misunderstanding of copy-on-write

This is a proper copy-on-write list

class COWList:
    def __init__(self, l, clone_of=None):
        self.l = l
        self.clones = []
        self.clone_of = clone_of

    def append(self, val):
        self.clear_clones()
        self.l.append(val)

    def set_item(self, idx, val):
        self.clear_clones()
        self.l[idx] = val

    def get_item(self, idx):
        return self.l[idx]

    def clone(self):
        c = COWList(self.l, self)
        self.clones.append(c)
        return c

    def clear_clones(self):
        if self.clone_of is not None:

note that even if self.l is a gigabyte big list

you can call self.clone() thousands of times

as long as you do not modify those clones, they do not copy the list

if you modify the original the clones also copy

Nathan Merrill

5:51 AM

wait...

so, lets say I have a, b, and c

they are all CowList clones

of a

if I modify a, it copies b and c?

orlp

correct

there is an opportunity to optimize it further

Nathan Merrill

simply point c to b?

orlp

yeah something like that

but that requires more code

Nathan Merrill

why not just copy a?

orlp

this was just to illustrate :)

@NathanMerrill because now b and c still think they're clones of a

ideally you just copy a

and then relink the clones such that one of the clones becomes the master, and the rest follows it

unless the number of clones is reduced to 1, which then just becomes normal

Nathan Merrill

5:54 AM

but say you have 2000 clones

orlp

    def clear_clones(self):
        self.l = self.l[:]
        self.clone_of = None
        if self.clones:
            new_orig = self.clones.pop()
            new_orig.clone_of = None
            for clone in self.clones:
                clone.clone_of = new_orig

Nathan Merrill

why not simply make a new copy, as opposed to updating the references of all of the clones?

actually, Wikipedia disagrees

"Instead they can all be given pointers to the same resource, with the provision that on the first occasion where they need to modify the data, they must first create a local copy on which to perform the modification (the original resource remains unchanged)"

orlp

@NathanMerrill in what way does it disagree?

Nathan Merrill

well, in your case, you are modifying the original resource

and then reupdating the pointers

orlp

not anymore

see the new clear_clones

oh damn it's stupid now, it always copies

one sec

def clear_clones(self):
    if self.clone_of or self.clones: self.l = self.l[:]
    self.clone_of = None
    if self.clones:
        new_orig = self.clones.pop()
        new_orig.clone_of = None
        for clone in self.clones:
            clone.clone_of = new_orig
        self.clones = []

Transcript for