<!DOCTYPE html><html><head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<font size="4" face="monospace">Dan is 100% correct here; there's a
reason we haven't pursued this, and it's not because we've never
used C++. It's not even a close call; it's an obvious loser.<br>
<br>
<blockquote type="cite"><span style="font-size:11.0pt;font-family:"Calibri","sans-serif";color:#1F497D">So
you think frozen objects will be any simpler?</span></blockquote>
<br>
Dan never suggested frozen objects were a good idea either;
someone asked a question about them, that's all. And it's
disingenuous to suggest that these are the only two options, or
that if you don't like A, then you must like B. <br>
<br>
</font><font size="4" face="monospace">(As a rule of thumb:
arguments that start with "So you think / so you're saying" are
almost never what that person things or is saying.)<br>
<br>
In any case, we are way outside the charter of amber-dev here. I
think best to stop here. <br>
</font><font size="4" face="monospace"><br>
</font><br>
<div class="moz-cite-prefix">On 12/21/2023 11:08 AM, Dan Heidinga
wrote:<br>
</div>
<blockquote type="cite" cite="mid:DS0PR10MB62713260C3B7967194814B8FE795A@DS0PR10MB6271.namprd10.prod.outlook.com">
<meta name="Generator" content="Microsoft Word 15 (filtered medium)">
<style>@font-face
{font-family:"Cambria Math";
panose-1:2 4 5 3 5 4 6 3 2 4;}@font-face
{font-family:Calibri;
panose-1:2 15 5 2 2 2 4 3 2 4;}@font-face
{font-family:Tahoma;
panose-1:2 11 6 4 3 5 4 4 2 4;}@font-face
{font-family:Aptos;
panose-1:2 11 0 4 2 2 2 2 2 4;}p.MsoNormal, li.MsoNormal, div.MsoNormal
{margin:0cm;
font-size:12.0pt;
font-family:"Times New Roman",serif;}a:link, span.MsoHyperlink
{mso-style-priority:99;
color:blue;
text-decoration:underline;}span.m7247407421996311182m-2682028665710061497gmailsignatureprefix
{mso-style-name:m7247407421996311182m-2682028665710061497gmailsignatureprefix;}span.EmailStyle20
{mso-style-type:personal-reply;
font-family:"Calibri",sans-serif;
color:windowtext;}.MsoChpDefault
{mso-style-type:export-only;
font-size:10.0pt;
mso-ligatures:none;}div.WordSection1
{page:WordSection1;}</style>
<div class="WordSection1">
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">Not
unsolvable but the payoff isn’t there.<o:p></o:p></span></p>
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"><o:p> </o:p></span></p>
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">None
of this is the hard work of figuring out what “const” would
mean in the language, how it would fit with return types,
method parameters, receivers, conversions, annotations,
reflection, methodhandles, debuggers and any other number of
existing features in Java.<o:p></o:p></span></p>
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"><o:p> </o:p></span></p>
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">If
“const” is something you really want to see added to Java,
then spend the time to work through the semantics and bring
a proposal with enough details worked out that it can be
discussed and debated on its merit.<o:p></o:p></span></p>
<p class="MsoNormal"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"><o:p> </o:p></span></p>
<div id="mail-editor-reference-message-container">
<div>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="mso-margin-top-alt:0cm;margin-right:0cm;margin-bottom:12.0pt;margin-left:36.0pt">
<b><span style="font-family:"Aptos",sans-serif;color:black" lang="DE">From:
</span>
</b><span style="font-family:"Aptos",sans-serif;color:black" lang="DE">Markus
Karg <a class="moz-txt-link-rfc2396E" href="mailto:markus@headcrashing.eu"><markus@headcrashing.eu></a><br>
<b>Date: </b>Thursday, December 21, 2023 at 10:52 AM<br>
<b>To: </b>'Red IO'
<a class="moz-txt-link-rfc2396E" href="mailto:redio.development@gmail.com"><redio.development@gmail.com></a>, Dan Heidinga
<a class="moz-txt-link-rfc2396E" href="mailto:dan.heidinga@oracle.com"><dan.heidinga@oracle.com></a><br>
<b>Cc: </b>'Holo The Sage Wolf'
<a class="moz-txt-link-rfc2396E" href="mailto:holo3146@gmail.com"><holo3146@gmail.com></a>, 'Archie Cobbs'
<a class="moz-txt-link-rfc2396E" href="mailto:archie.cobbs@gmail.com"><archie.cobbs@gmail.com></a>, 'amber-dev'
<a class="moz-txt-link-rfc2396E" href="mailto:amber-dev@openjdk.org"><amber-dev@openjdk.org></a><br>
<b>Subject: </b>AW: [External] : AW: Frozen objects?<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE">You are right, backwards compatibility
without introducing const_cast as in C++ is a problem.
But that does not neither man that we MUST introduce
const_cast nor that the problem is not solvable.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE">-Markus</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE"> </span><span lang="DE"><o:p></o:p></span></p>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="margin-left:36.0pt"><b><span style="font-size:10.0pt;font-family:"Tahoma",sans-serif" lang="DE">Von:</span></b><span style="font-size:10.0pt;font-family:"Tahoma",sans-serif" lang="DE"> Red IO
[<a class="moz-txt-link-freetext" href="mailto:redio.development@gmail.com">mailto:redio.development@gmail.com</a>]
<br>
<b>Gesendet:</b> Donnerstag, 21. Dezember 2023 16:06<br>
<b>An:</b> Dan Heidinga<br>
<b>Cc:</b> Markus Karg; Holo The Sage Wolf; Archie
Cobbs; amber-dev<br>
<b>Betreff:</b> Re: [External] : AW: Frozen objects?</span><span lang="DE"><o:p></o:p></span></p>
</div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">I think const is a pretty fine concept,
the confusion in c++ primarily comes from it's
confusing syntax and having multiple meanings like
const member functions.<o:p></o:p></span></p>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">A conversion from const to non const
just makes no sense. You can use every non const
object like a const one but never the other way
around. <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">I prefer the inverted rust equivalent
"mut" more as it makes the point more clear. If
you share a mutable reference you expect the
recipient to mutate your data, if you pass an
immutable reference you can be ensured the
recipient won't change your data. <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">It's just a contract rather or not some
value can be mutated and rather or not a method
requires to mutate it's parameters.<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">In java we currently are stuck with
exception throwing views, documentation and
defensive copies. <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">I'm not sure rather adding an internal
mutability system afterwards is possible or a good
idea. Especially old libraries would require some
sort of const cast to be usable. Which would
undermine the certainty such a system provides.<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">Best regards<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">RedIODev<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
</div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE"> <o:p></o:p></span></p>
<div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span lang="DE">On Wed, Dec 20, 2023, 17:58 Dan Heidinga
<<a href="mailto:dan.heidinga@oracle.com" moz-do-not-send="true" class="moz-txt-link-freetext">dan.heidinga@oracle.com</a>>
wrote:<o:p></o:p></span></p>
</div>
<blockquote style="border:none;border-left:solid #CCCCCC 1.0pt;padding:0cm 0cm 0cm 6.0pt;margin-left:4.8pt;margin-top:5.0pt;margin-right:0cm;margin-bottom:5.0pt">
<div>
<div>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">C++
“const” is a bit of a mess. It’s not only a
local property that prevents writes to the
reference; it’s also a viral property that
infects the type system. Instead of dealing
with a single type (“X”), we now have two
(“X”, “const X”) with a 1-way conversion from
“X -> const X” but no conversion back
(Let’s not talk about const_cast’s undefined
behaviour….). Now methods need to be defined
to take either an X or a const X parameter and
need to flow the const through to all their
callers.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">But
that’s not all – now we need to be able to
mark virtual methods to declare if the
receiver is const or not. And to mark return
types as const or not.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">There’s
a pretty massive cost to the user’s mental
model and to the language as well as producing
on-going compatibility problems (is adding or
removing “const” modifiers binary compatible?
Source compatible?) for library evolution.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif">Syntactic
sugar to indicate “I won’t write to this”
doesn’t really pay its way. The costs are
quite high.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:36.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif"> </span><span lang="DE"><o:p></o:p></span></p>
<div id="m_7247407421996311182mail-editor-reference-message-container">
<div>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="mso-margin-top-alt:0cm;margin-right:0cm;margin-bottom:12.0pt;margin-left:72.0pt">
<b><span style="font-family:"Arial",sans-serif;color:black" lang="DE">From:
</span>
</b><span style="font-family:"Arial",sans-serif;color:black" lang="DE">Markus
Karg <<a href="mailto:markus@headcrashing.eu" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">markus@headcrashing.eu</a>><br>
<b>Date: </b>Wednesday, December 20,
2023 at 5:32 AM<br>
<b>To: </b>'Holo The Sage Wolf' <<a href="mailto:holo3146@gmail.com" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">holo3146@gmail.com</a>><br>
<b>Cc: </b>Dan Heidinga <<a href="mailto:dan.heidinga@oracle.com" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">dan.heidinga@oracle.com</a>>,
'Archie Cobbs' <<a href="mailto:archie.cobbs@gmail.com" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">archie.cobbs@gmail.com</a>>,
'amber-dev' <<a href="mailto:amber-dev@openjdk.org" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">amber-dev@openjdk.org</a>><br>
<b>Subject: </b>[External] : AW: Frozen
objects?</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE">C++ ("const") does not freeze
the memory region at all, and it does
not need to (and hence is quite fast at
runtime as it does not even need to
check the access). The compiler simply
rejects to compile the attempt to write
via read-only references. That would be
sufficient for most cases. Freezing
objects is a different idea, and only
needed in side cases. So I would plea
for introducing compile-time read-only
references first, as it is the lower
hanging fruit.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE">-Markus</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;font-family:"Calibri",sans-serif;color:#1F497D" lang="DE"> </span><span lang="DE"><o:p></o:p></span></p>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="margin-left:72.0pt"><b><span style="font-size:10.0pt;font-family:"Tahoma",sans-serif" lang="DE">Von:</span></b><span style="font-size:10.0pt;font-family:"Tahoma",sans-serif" lang="DE"> Holo The Sage Wolf [mailto:<a href="mailto:holo3146@gmail.com" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">holo3146@gmail.com</a>]
<br>
<b>Gesendet:</b> Dienstag, 19.
Dezember 2023 14:18<br>
<b>An:</b> Markus Karg<br>
<b>Cc:</b> Dan Heidinga; Archie Cobbs;
amber-dev<br>
<b>Betreff:</b> Re: Frozen objects?</span><span lang="DE"><o:p></o:p></span></p>
</div>
<p class="MsoNormal" style="margin-left:72.0pt"><span lang="DE"> <o:p></o:p></span></p>
<div>
<div>
<p class="MsoNormal" style="margin-left:72.0pt"><span lang="DE">How do you freeze a memory
region without talking about
freezing objects?<o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:72.0pt"><span lang="DE"> <o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="mso-margin-top-alt:0cm;margin-right:0cm;margin-bottom:12.0pt;margin-left:72.0pt">
<span lang="DE">Unless your data is
flat (so only value classes,
primitives and arrays, 2 of which
won't benefit from freezing) the
only way to have freezing something
that is enforced at compile time you
must talk about objects.<o:p></o:p></span></p>
<div>
<div>
<p class="MsoNormal" style="margin-left:72.0pt"><span lang="DE">On Tue, 19 Dec 2023,
10:04 Markus Karg, <</span><a href="mailto:markus@headcrashing.eu" target="_blank" moz-do-not-send="true"><span lang="DE">markus@headcrashing.eu</span></a><span lang="DE">> wrote:<o:p></o:p></span></p>
</div>
<blockquote style="border:none;border-left:solid #CCCCCC 1.0pt;padding:0cm 0cm 0cm 6.0pt;margin-left:4.8pt;margin-top:5.0pt;margin-right:0cm;margin-bottom:5.0pt">
<div>
<div>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;color:#1F497D" lang="DE">I wonder why we discuss
about freezing *objects*
(which needs time) but not
simply freezing *references*
(like `const` does in C++)?</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;color:#1F497D" lang="DE">-Markus</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;color:#1F497D" lang="DE"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt;color:#1F497D" lang="DE"> </span><a name="m_7247407421996311182_m_-268202866571006" moz-do-not-send="true"></a><span lang="DE"><o:p></o:p></span></p>
<div>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="margin-left:72.0pt"><b><span style="font-family:"Tahoma",sans-serif" lang="DE">Von:</span></b><span style="font-family:"Tahoma",sans-serif" lang="DE"> amber-dev
[mailto:</span><a href="mailto:amber-dev-retn@openjdk.org" target="_blank" moz-do-not-send="true"><span style="font-family:"Tahoma",sans-serif" lang="DE">amber-dev-retn@openjdk.org</span></a><span style="font-family:"Tahoma",sans-serif" lang="DE">]
<b>Im Auftrag von </b>Dan
Heidinga<br>
<b>Gesendet:</b> Montag,
18. Dezember 2023 16:04<br>
<b>An:</b> Archie Cobbs;
amber-dev<br>
<b>Betreff:</b> Re:
Frozen objects?</span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<p class="MsoNormal" style="margin-left:72.0pt"><span lang="DE"> <o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt">Let
me throw out one other
concern: races. The
invariant frozen objects
want is that the application
and runtime can trust they
will never be mutated
again. Unfortunately, if
the object is published
across threads before it is
frozen, then that invariant
is very difficult and
expensive to maintain.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt">If
two threads, A & B, both
have references to the
object and thread A freezes
it, B may still be
publishing writes to it that
A only observes later. To
ensure the right JMM
happens-before relationship
for fields of Freezable
objects, both reads and
writes would need to be more
expensive (volatile
semantics?) until a thread
could validate the object it
was operating on was frozen.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt">Freezing
is not just a free set of
unexplored optimizations.
There’re also new costs
associated with it across
the runtime (field
read/write, profiling, etc).
</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt">--Dan</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:72.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
<div id="m_7247407421996311182m_-2682028665710061497mail-editor-reference-message-container">
<div>
<div style="border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0cm 0cm 0cm">
<p class="MsoNormal" style="mso-margin-top-alt:0cm;margin-right:0cm;margin-bottom:12.0pt;margin-left:108.0pt">
<b><span style="color:black">From:
</span></b><span style="color:black">amber-dev
<</span><a href="mailto:amber-dev-retn@openjdk.org" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">amber-dev-retn@openjdk.org</a><span style="color:black">>
on behalf of Archie
Cobbs <</span><a href="mailto:archie.cobbs@gmail.com" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">archie.cobbs@gmail.com</a><span style="color:black">><br>
<b>Date: </b>Saturday,
December 16, 2023 at
12:33 PM<br>
<b>To: </b>amber-dev
<</span><a href="mailto:amber-dev@openjdk.org" target="_blank" moz-do-not-send="true" class="moz-txt-link-freetext">amber-dev@openjdk.org</a><span style="color:black">><br>
<b>Subject: </b>Frozen
objects?</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Caveat: I'm
just trying to
educate myself on
what's been
discussed in the
past, not actually
suggest a new
language feature.
I'm sure this kind
of idea has been
discussed before so
feel free to point
me at some previous
thread, etc.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">In C we have
'const' which
essentially means
"the memory
allocated to this
thing is immutable".
The nice thing about
'const' is that it
can apply to an
individual variable
or field in a
structure, or it can
apply to an entire C
structure or C
array. In effect it
applies to any
contiguous memory
region that can be
named/identified at
the language level.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">On the other
hand, it's just
a language
fiction, i.e.,
it can always be
defeated at
runtime by
casting (except
for static
constants).</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">In Java we
have 'final' which
(in part) is like
'const' for fields
and variables, but
unlike C 'final'
can't be applied
to larger memory
regions like
entire objects or
entire arrays.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">In C, 'const'
can be applied
"dynamically" in
the sense I can
cast foo to const
foo. Of course,
this is only
enforced at the
language level.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Summary of
differences
between C 'const'
and Java 'final':</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Granularity:</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">C: Any contiguous memory region that has a
language
name/identification</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Java: At most 64 bits at a time (*) and arrays
are not included</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Advantage: C</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Enforcement:</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">C: Enforced only by the compiler (mostly)</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Java: Enforced by the compiler and at runtime</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Advantage: Java</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Dynamic Application:</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">C: Yes</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Java: No</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Advantage: C</span><span lang="DE"><o:p></o:p></span></p>
</div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">(*) With
records and value
objects we are
gradually moving
towards the ability
for larger things
than an individual
field to be 'const'.
More generally, Java
has slowly been
glomming on some of
the goodness from
functional
programming,
including making it
easier to declare
and work with
immutable data.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">This all begs
the question: why
not take this idea
to its logical
conclusion? And
while we're at it,
make the capability
fully dynamic,
instead of limiting
when you can
'freeze' something
construction time?</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">In other
words, add the
ability to "freeze"
an object or array.
If 'x' is frozen,
whatever 'x'
directly references
becomes no longer
mutable.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">A rough
sketch...</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Add new
</span><span style="font-size:11.0pt;font-family:"Courier New"">Freezable</span><span style="font-size:11.0pt"> interface:</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New""> public
interface
Freezable {</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
boolean
isFrozen();</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
static boolean
freeze(Freezable
obj); // returns
false if already
frozen</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New""> }</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Arrays
automatically
implement
</span><span style="font-size:11.0pt;font-family:"Courier New"">Freezable</span><span style="font-size:11.0pt"> (just like they do
</span><span style="font-size:11.0pt;font-family:"Courier New"">Cloneable</span><span style="font-size:11.0pt">)</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">What about
the memory model?
Ideally it would
work as if written
like this:</span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New""> public
class Foo
implements
Freezable {</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
private volatile
frozen; // set
to true by
Freezable.freeze()</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
void
mutateFooContent(Runnable
mutation) {</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
if (this.frozen)</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
throw new
FrozenObjectException();</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
else</span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New"">
mutation.run();</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New""> }</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt;font-family:"Courier New""> }</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">But there
could be a better
trade-off of
performance vs.
semantics.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Other
trade-offs...</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(-) All mutations to a </span><span style="font-size:11.0pt;font-family:"Courier New"">Freezable</span><span style="font-size:11.0pt"> would require a new 'frozen' check (* see
below)</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(-) There would have to be a new bit allocated
in the object header</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(+) Eliminate zillions of JDK defensive array
copies (things like
</span><span style="font-size:11.0pt;font-family:"Courier New"">String.toCharArray()</span><span style="font-size:11.0pt">)</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(+) JIT optimizations for constant-folding,
etc.</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:144.0pt"><span style="font-family:Symbol">·</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(+) GC optimizations</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">(*) Put frozen objects into a read-only region
of memory to
eliminate mutation
checks</span><span lang="DE"><o:p></o:p></span></p>
<p class="MsoNormal" style="margin-left:180.0pt"><span style="font-family:"Courier New"">o</span><span style="font-size:7.0pt">
</span><span style="font-size:11.0pt">Optimize scanning of frozen references (since
they never change)</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">I'm curious
how other people
think this idea
would or wouldn't
make sense for Java
& what's been
decided in the past.</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Thanks,</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">-Archie</span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt"> </span><span lang="DE"><o:p></o:p></span></p>
</div>
<div>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span class="m7247407421996311182m-2682028665710061497gmailsignatureprefix"><span style="font-size:11.0pt">--
</span></span><span lang="DE"><o:p></o:p></span></p>
<div>
<p class="MsoNormal" style="margin-left:108.0pt"><span style="font-size:11.0pt">Archie L.
Cobbs</span><span lang="DE"><o:p></o:p></span></p>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</blockquote>
<br>
</body>
</html>