Sunday, January 19, 2020

Digest for comp.lang.c++@googlegroups.com - 5 updates in 3 topics

Wisdom90 <d@d.d>: Jan 19 05:56PM -0500

Hello..
 
 
As you have noticed i have just posted previously about
safe languages like ADA and unsafe languages like C and C++,
now i will write more about safe and unsafe languages:
 
About safe and unsafe languages..
 
We use the term safe to refer to languages that automatically
perform runtime checks to prevent programs from violating the
bounds of allocated memory. Safe languages must provide two
properties to ensure that programs respect allocation bounds:
memory safety and type safety.
 
Memory safety is the real goal, it means that the program
will not read or write data outside the bounds of allocated
regions. To achieve memory safety, a language must also enforce
type safety so that it can keep track of the memory allocation
bounds. Without type safety, any arbitrary value could be used
as a reference into memory.
 
Beyond the possibility of buffer overflow, unsafe languages,
such as C and C++, value compile-time optimization and concise
expression over safety and comprehensibility, which are key
features of safe languages. This difference in priorities is
evidenced by the fact that most unsafe languages allow programs
to directly access low-level system resources, including memory.
In contrast, safe languages must explicitly control the ways
programs are allowed to access resources, to prevent violations
of the properties that they guarantee.
 
Fundamental to the trade-off between safe and unsafe languages
is the concept of trust. Unsafe languages implicitly trust the
programmer, while safe languages explicitly limit the operations
that they allow in exchange for the capability to prevent programs
from making potentially damaging mistakes. The result is that
unsafe languages are more powerful with respect to the operations
that can be performed, while safe languages provide greater reusable
functionality with built-in protections that often make programmers
more efficient. Another side-effect of a small set of low-level
operations is that complex problems can typically be solved more
concisely in unsafe languages, which is often seen as another
advantage over safe languages.
 
Many of the distinctions that often accompany the difference
between safe and unsafe languages are technically unnecessary.
It is possible to implement a safe language that provides a
small instruction set and low-level access to nonmemory
resources, such as the network and filesystem. However,
because the additional record keeping and checks required
to make a language safe degrade the performance of compile-time
optimization strategies, memory-safe languages have typically
been deemed unacceptable for certain types of programs.
 
Recently, security concerns have prompted limited reconsideration
of these tradeoffs. Safe languages designed with performance and
flexibility in mind have been created in academic circles and
have been shown to effectively prevent buffer overflow
vulnerabilities, albeit at a performance cost. The section on
safe C dialects gives an overview of two of the more complete
implementations.
 
 
Thank you,
Amine Moulay Ramdane.
Wisdom90 <d@d.d>: Jan 19 05:56PM -0500

On 1/19/2020 5:56 PM, Wisdom90 wrote:
> implementations.
 
> Thank you,
> Amine Moulay Ramdane.
 
 
 
Sorry, i have posted in the wrong group.
 
 
Thank you,
Amine Moulay Ramdane.
legalize+jeeves@mail.xmission.com (Richard): Jan 19 07:13PM

[Please do not mail me a copy of your followup]
 
Lynn McGuire <lynnmcguire5@gmail.com> spake the secret code
 
>Huh ? Don't tell that to Hungarian notation folks.
> https://en.wikipedia.org/wiki/Hungarian_notation
 
It was always a bad idea. Even MS has disavowed it at this point.
The C# coding style guidelines specifically tell you *not* to use
this.
--
"The Direct3D Graphics Pipeline" free book <http://tinyurl.com/d3d-pipeline>
The Terminals Wiki <http://terminals-wiki.org>
The Computer Graphics Museum <http://computergraphicsmuseum.org>
Legalize Adulthood! (my blog) <http://legalizeadulthood.wordpress.com>
Christian Gollwitzer <auriocus@gmx.de>: Jan 19 09:55AM +0100


> I think you are missing the forest for the trees. This
> is the CMW ambassador:
 
> https://github.com/Ebenezer-group/onwards/blob/master/src/cmw/tiers/cmwA.cc
 
I think you didn't understand what I was writing:
 
https://github.com/Ebenezer-group/onwards/commits/master/src/cmw/tiers/cmwA.cc
 
The commit history doesn't tell me anything. No useful messages.
 
Christian
Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk>: Jan 19 06:17PM

On 19/01/2020 08:55, Christian Gollwitzer wrote:
 
> I think you didn't understand what I was writing:
 
> https://github.com/Ebenezer-group/onwards/commits/master/src/cmw/tiers/cmwA.cc
 
> The commit history doesn't tell me anything. No useful messages.
 
But surely just knowing that all the changes are simply "tweaks" is all you need to know! </sarcasm>
 
/Flibble
 
--
"Snakes didn't evolve, instead talking snakes with legs changed into snakes." - Rick C. Hodgin
 
"You won't burn in hell. But be nice anyway." – Ricky Gervais
 
"I see Atheists are fighting and killing each other again, over who doesn't believe in any God the most. Oh, no..wait.. that never happens." – Ricky Gervais
 
"Suppose it's all true, and you walk up to the pearly gates, and are confronted by God," Byrne asked on his show The Meaning of Life. "What will Stephen Fry say to him, her, or it?"
"I'd say, bone cancer in children? What's that about?" Fry replied.
"How dare you? How dare you create a world to which there is such misery that is not our fault. It's not right, it's utterly, utterly evil."
"Why should I respect a capricious, mean-minded, stupid God who creates a world that is so full of injustice and pain. That's what I would say."
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.

No comments: