• Andrei Alexandrescu (9/9) Jan 13 2016 Hey folks, I want to push things forward with artifacts dedicated to
• rsw0x (17/28) Jan 13 2016 std.experimental.mm ?
• userABCabc123 (6/17) Jan 13 2016 std.experimental.gcfree
• Ilya (3/14) Jan 13 2016 std.memory --Ilya
• ref2401 (2/3) Jan 14 2016 That's a good one.
• Meta (16/27) Jan 13 2016 Aside from that, naming it std.experimental.nogc is a bad idea
• Jack Stouffer (6/9) Jan 13 2016 There are only two hard things in Computer Science: cache
• Anonymouse (3/6) Jan 13 2016 std.samesamebutdifferent
• Vladimir Panteleev (3/13) Jan 13 2016 std.experimental.lifetime
• Andrei Alexandrescu (2/14) Jan 14 2016 noice -- Andrei
• Jacob Carlborg (7/14) Jan 13 2016 std.experimental.memory with submodules for the different use cases:
• Brian Schott (3/8) Jan 14 2016 Agreed.
• Robert burner Schadek (4/9) Jan 14 2016 this has my vote
• bachmeier (3/6) Jan 14 2016 +1
• Andrei Alexandrescu (3/8) Jan 14 2016 I don't see how this categorization works. E.g. there's no need for
• Jacob Carlborg (5/7) Jan 14 2016 It was just a couple of suggestions. I don't know exactly what you're
• Andrei Alexandrescu (2/7) Jan 14 2016 Me neither, which adds to the problem :o). -- Andrei
• Jacob Carlborg (5/6) Jan 14 2016 You need to at least have some ideas, otherwise there's no point in a
• Rikki Cattermole (9/18) Jan 14 2016 I can already suggest one thing.
• ZombineDev (9/20) Jan 17 2016 That's not true. All of http://dlang.org/phobos/core_memory is
• karabuta (3/23) Jan 16 2016 +1
• karabuta (2/8) Jan 16 2016 Simplifies things IMO
• qznc (6/9) Jan 18 2016 This "rc" is "reference counting"? Reference counting is also a
• Jacob Carlborg (5/9) Jan 18 2016 They are suggestions. More an indication that he doesn't need to come up...
• Jack (3/6) Jan 14 2016 std.experimental.rusty
• Guillaume Piolat (7/8) Jan 14 2016 import std.experimental.gcbypass;
• Chris (6/17) Jan 15 2016 Will there also be an article about how to integrate the new

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

Hey folks, I want to push things forward with artifacts dedicated to 
avoiding the GC, and of course my main worry is finding the right name.

An obvious choice is std.experimental.nogc but we know from Marketing 
101 that expressing something as a positive is better than a negative. 
Another possibility is std.experimental.rc, but that's imprecise because 
the artifacts in there will contain a variety of things in addition to 
reference counting-related artifacts.

Ideas?


Andrei

rsw0x <anonymous anonymous.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?


 Andrei

std.experimental.mm ?
mm => memory management

It would be interesting to know what you plan on putting in 
there. There's a few functions that duplicate utility in Phobos 
but one allocates and the other doesn't — e.g, lineSplitter. 
lineSplitter is 4-5x faster than the equivalent GC 
version(splitLines) according to my benchmarks.

I think one of the bigger issues with Phobos using the GC isn't 
that it uses the GC, but many functions allocate far more than 
they need to. I've seen Rust referred to as too focused on memory 
management(in fact, I think it was you that referred to Rust as 
this) but I think D sometimes goes in the opposite direction 
making it too easy to forget about memory management and just 
allocate everywhere because it's very implicit.

Bye.

userABCabc123 <userABCabc123 ab.bc> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?


 Andrei

std.experimental.gcfree
std.experimental.unmanaged
std.experimental.uncollected
std.experimental.mmm (manual mem managment)

Ilya <ilyayaroshenko gmail.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?


 Andrei

std.memory --Ilya

ref2401 <refactor24 gmail.com> writes:

On Thursday, 14 January 2016 at 02:13:20 UTC, Ilya wrote:

 std.memory --Ilya

That's a good one.

Meta <jared771 gmail.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?


 Andrei

Aside from that, naming it std.experimental.nogc is a bad idea 
because it'll
confuse newcomers, thinking it's somehow related to  nogc... 
Which it is, but
we don't want people importing std.experimental.nogc because they 
think they
need to do that to use  nogc.

Ideas:

std.experimental.gcless (still negative)
std.experimental.gcfree
std.experimental.realtime
std.experimental.pausefree
std.experimental.manualheap
std.experimental.manualmem

Jack Stouffer <jack jackstouffer.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

There are only two hard things in Computer Science: cache 
invalidation and naming things. -- Phil Karlton

I'd go with std.memory or std.memory_management as others have 
suggested.

Anonymouse <asdf fdsa.nu> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

std.samesamebutdifferent

Vladimir Panteleev <thecybershadow.lists gmail.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?

std.experimental.lifetime

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

On 01/14/2016 12:48 AM, Vladimir Panteleev wrote:
 On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu wrote:
 Hey folks, I want to push things forward with artifacts dedicated to
 avoiding the GC, and of course my main worry is finding the right name.

 An obvious choice is std.experimental.nogc but we know from Marketing
 101 that expressing something as a positive is better than a negative.
 Another possibility is std.experimental.rc, but that's imprecise
 because the artifacts in there will contain a variety of things in
 addition to reference counting-related artifacts.

 Ideas?

 std.experimental.lifetime

noice -- Andrei

Jacob Carlborg <doob me.com> writes:

On 2016-01-14 01:35, Andrei Alexandrescu wrote:
 Hey folks, I want to push things forward with artifacts dedicated to
 avoiding the GC, and of course my main worry is finding the right name.

 An obvious choice is std.experimental.nogc but we know from Marketing
 101 that expressing something as a positive is better than a negative.
 Another possibility is std.experimental.rc, but that's imprecise because
 the artifacts in there will contain a variety of things in addition to
 reference counting-related artifacts.

std.experimental.memory with submodules for the different use cases:

std.experimental.memory.rc
std.experimental.memory.gc
std.experimental.memory.manual // or something

-- 
/Jacob Carlborg

Brian Schott <briancschott gmail.com> writes:

On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
wrote:
 std.experimental.memory with submodules for the different use 
 cases:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

Agreed.

Robert burner Schadek <rburners gmail.com> writes:

On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
wrote:
 std.experimental.memory with submodules for the different use 
 cases:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

this has my vote

I guess the first submodule should be the allocators!?

bachmeier <no spam.com> writes:

On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
wrote:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

+1

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

On 01/14/2016 09:50 AM, bachmeier wrote:
 On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg wrote:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

 +1

I don't see how this categorization works. E.g. there's no need for 
special tooling related to the GC. -- Andrei

Jacob Carlborg <doob me.com> writes:

On 2016-01-14 15:52, Andrei Alexandrescu wrote:

 I don't see how this categorization works. E.g. there's no need for
 special tooling related to the GC. -- Andrei

It was just a couple of suggestions. I don't know exactly what you're 
going to include in this module.

-- 
/Jacob Carlborg

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

On 01/14/2016 10:46 AM, Jacob Carlborg wrote:
 On 2016-01-14 15:52, Andrei Alexandrescu wrote:

 I don't see how this categorization works. E.g. there's no need for
 special tooling related to the GC. -- Andrei

 It was just a couple of suggestions. I don't know exactly what you're
 going to include in this module.

Me neither, which adds to the problem :o). -- Andrei

Jacob Carlborg <doob me.com> writes:

On 2016-01-14 17:11, Andrei Alexandrescu wrote:

 Me neither, which adds to the problem :o). -- Andrei

You need to at least have some ideas, otherwise there's no point in a 
new module :)

-- 
/Jacob Carlborg

Rikki Cattermole <alphaglosined gmail.com> writes:

On 15/01/16 5:11 AM, Andrei Alexandrescu wrote:
 On 01/14/2016 10:46 AM, Jacob Carlborg wrote:
 On 2016-01-14 15:52, Andrei Alexandrescu wrote:

 I don't see how this categorization works. E.g. there's no need for
 special tooling related to the GC. -- Andrei

 It was just a couple of suggestions. I don't know exactly what you're
 going to include in this module.

 Me neither, which adds to the problem :o). -- Andrei

I can already suggest one thing.

I'm currently working on a library solution to my managed memory 
concept. I should have it completed within a day or so.

I will be replacing the dummy ref counted solution I built for 
alphaPhobos with this. As it allows me a LOT more control over the memory.

And it will be wonderful for containers with secondary ownership and all 
that :)

http://wiki.dlang.org/User:Alphaglosined/ManagedMemory

ZombineDev <valid_email he.re> writes:

On Thursday, 14 January 2016 at 14:52:19 UTC, Andrei Alexandrescu 
wrote:
 On 01/14/2016 09:50 AM, bachmeier wrote:
 On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
 wrote:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

 +1

 I don't see how this categorization works. E.g. there's no need 
 for special tooling related to the GC. -- Andrei

That's not true. All of http://dlang.org/phobos/core_memory is 
about the GC. If some of the low-level stuff are put in druntime, 
then this categorization would look nice:

core.memory.gc (previously just core.memory)
core.memory.manual (something along the lines of 
https://github.com/D-Programming-Language/phobos/pull/3031)
core.memory.rc (Unique/Isolated and Shared smart pointers)

karabuta <karabutaworld gmail.com> writes:

On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
wrote:
 On 2016-01-14 01:35, Andrei Alexandrescu wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to
 avoiding the GC, and of course my main worry is finding the 
 right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing
 101 that expressing something as a positive is better than a 
 negative.
 Another possibility is std.experimental.rc, but that's 
 imprecise because
 the artifacts in there will contain a variety of things in 
 addition to
 reference counting-related artifacts.

 std.experimental.memory with submodules for the different use 
 cases:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

+1

karabuta <karabutaworld gmail.com> writes:

On Saturday, 16 January 2016 at 15:56:39 UTC, karabuta wrote:
 On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
 wrote:

 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

 +1


Simplifies things IMO

qznc <qznc web.de> writes:

On Thursday, 14 January 2016 at 07:44:16 UTC, Jacob Carlborg 
wrote:
 std.experimental.memory.rc
 std.experimental.memory.gc
 std.experimental.memory.manual // or something

This "rc" is "reference counting"? Reference counting is also a 
form of garbage collection ("gc"). So I don't like this 
classification. If we really want "rc", then something like 
"trace" instead of "gc" should be the alternative.

Jacob Carlborg <doob me.com> writes:

On 2016-01-18 09:40, qznc wrote:

 This "rc" is "reference counting"? Reference counting is also a form of
 garbage collection ("gc"). So I don't like this classification. If we
 really want "rc", then something like "trace" instead of "gc" should be
 the alternative.

They are suggestions. More an indication that he doesn't need to come up 
with a weird name that can fit anything.

-- 
/Jacob Carlborg

Jack <jack gmail.com> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 
 Ideas?

 Andrei

std.experimental.rusty

Guillaume Piolat <contact gam3sfrommars.fr> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Ideas?

import std.experimental.gcbypass;
import std.experimental.gcfreedom;
import std.experimental.shuntgc;
import std.experimental.rcinstead;
import std.experimental.manual;

Chris <wendlec tcd.ie> writes:

On Thursday, 14 January 2016 at 00:35:53 UTC, Andrei Alexandrescu 
wrote:
 Hey folks, I want to push things forward with artifacts 
 dedicated to avoiding the GC, and of course my main worry is 
 finding the right name.

 An obvious choice is std.experimental.nogc but we know from 
 Marketing 101 that expressing something as a positive is better 
 than a negative. Another possibility is std.experimental.rc, 
 but that's imprecise because the artifacts in there will 
 contain a variety of things in addition to reference 
 counting-related artifacts.

 Ideas?


 Andrei

Will there also be an article about how to integrate the new 
memory model(s) into existing code? Something along the lines of 
"How to make existing code GC free". It'd be great to have a 
guide that shows how to do it properly.