Friday, May 18, 2018

Digest for comp.lang.c++@googlegroups.com - 25 updates in 14 topics

red floyd <dont.bother@its.invalid>: May 17 04:52PM -0700

On 5/17/2018 1:38 PM, Christian Gollwitzer wrote:
> configurable option even), before that ALL programs shared a single big
> event loop, with the consequences that a single stalled program would
> halt the whole machine, including the blinking cursor.
 
Anything that supported the Win32 API -- 95, 98, Me, all flavors of NT,
XP, Vista, 7, 8, and 10 -- had threading. It may not have been the
world's best implementation (9x and Me), but they supported threads.
Robert Wessel <robertwessel2@yahoo.com>: May 17 11:02PM -0500

On Thu, 17 May 2018 16:52:17 -0700, red floyd
 
>Anything that supported the Win32 API -- 95, 98, Me, all flavors of NT,
>XP, Vista, 7, 8, and 10 -- had threading. It may not have been the
>world's best implementation (9x and Me), but they supported threads.
 
 
Win32s did not.
Robert Wessel <robertwessel2@yahoo.com>: May 17 11:13PM -0500

On Thu, 17 May 2018 22:38:33 +0200, Christian Gollwitzer
>configurable option even), before that ALL programs shared a single big
>event loop, with the consequences that a single stalled program would
>halt the whole machine, including the blinking cursor.
 
 
At least for Windows applications, using the normal APIs, none of the
Win3.x family supported preemptive multitasking. You *could* do some
things like that in the VxD layer, or between multiple DOS sessions
(at least if you were running in 386Enh mode).
 
The fixes in later versions of Win16 for the single input queue did
not create preemptive multitasking, tasks could still only switch when
a Yield() was executed (which usually happened under the hood during
message processing), but under certain circumstances input messages
were considered processed as soon as the task accepted them, rather
than when the task returned for another message.
David Brown <david.brown@hesbynett.no>: May 18 09:57AM +0200

On 18/05/18 06:13, Robert Wessel wrote:
> Win3.x family supported preemptive multitasking. You *could* do some
> things like that in the VxD layer, or between multiple DOS sessions
> (at least if you were running in 386Enh mode).
 
Yes, it was weird like that - you could have pre-emptive multitasking of
DOS sessions, but not Windows programs on Win3.x. (OS/2 was far better
for running Windows and DOS programs at the time, as it /did/ support
pre-emptive multitasking. It still suffered from a single input queue
until 4.0 - that was MS' contribution to the joint OS/2 project.)
 
> message processing), but under certain circumstances input messages
> were considered processed as soon as the task accepted them, rather
> than when the task returned for another message.
 
I believe MacOS continued with cooperative multitasking for a long time
after Windows had switched to pre-emptive. But it worked on the Mac,
mainly because Mac application developers understood that cooperative
multitasking meant playing nice with other programs. Windows developers
often had a DOS background, and were used to the idea of being in full
control of the machine - yield() was not commonly used.
Robert Wessel <robertwessel2@yahoo.com>: May 18 03:58AM -0500

On Fri, 18 May 2018 09:57:50 +0200, David Brown
>multitasking meant playing nice with other programs. Windows developers
>often had a DOS background, and were used to the idea of being in full
>control of the machine - yield() was not commonly used.
 
 
While explicit yields were quite rare (and rarely called for), they
were usually done for you under the hood when you checked for
messages. They'd also happen for things like SendMessage where the
message went to a different task. Most of the time a well behaved
program with a large compute job would have checked messages
periodically, and not used Yield(). That would allow other
applications to run, and messages to be processed, including for the
compute task itself.
 
Still you point stands - far too many Windows applications would let
themselves burn 100% CPU for far too long.
 
But even a non-preemptive threading facility would have been a nice
addition to Win16. And would not have been hard to do (it wasn't all
that hard to fake with a separate process, but that was a bit clumsy).
In such a scenario, explicit yields would have been more common.
Vir Campestris <vir.campestris@invalid.invalid>: May 18 10:08PM +0100

> Really? How do you think all the various GUI events were run in the background
> then while your application ran its main thread? Or do you remember having
> to - for example - explicitely program the cursor to flash in a text box?
 
By queuing events to be handled by the main event loop.
 
Andy
Vir Campestris <vir.campestris@invalid.invalid>: May 18 10:50PM +0100

> Since windows couldn't (and AFAIK still doesn't) support fork(),
 
It has some good reasons for that.
Windows will guarantee that (except for HW fails) a page fault will
work. You'll get the memory that is behind that page. It's not like *nix
systems where overcommit and copy-on-write are common, and any page
fault can randomly take your app down because it can't be fulfilled.
This doesn't happen often, and TBH most Windows apps can't cope with a
malloc fail, but it is a design weakness.
Without overcommit and copy on write fork() would take an age. You'd
have to allocate backing space for every page in the new process (which
is what Windows does on malloc) and that would take a while.
Perhaps the advantages of fork outweigh that, but can be a problem.
 
> it had to start from main() again with presumably a load of command line
> parameters required to tell it what to do. God knows how you'd pass any
> binary data in, I guess a temporary file. Ugh.
 
Apparently you've never heard of a pipe? That says a lot for your
programming.
 
Andy
Melzzzzz <Melzzzzz@zzzzz.com>: May 18 10:09PM

> fault can randomly take your app down because it can't be fulfilled.
> This doesn't happen often, and TBH most Windows apps can't cope with a
> malloc fail, but it is a design weakness.
 
I don't understand. Windows does not have overcommit?
 
> Without overcommit and copy on write fork() would take an age.
 
That does not have to do anything with overcommit, rather
it is sepparate issue. COW is simply that , COW, overcommit is
overcommit.
 
You'd
> have to allocate backing space for every page in the new process (which
> is what Windows does on malloc) and that would take a while.
 
Have you know that when doing mmap system does not actually map page
until touched?
 
>> binary data in, I guess a temporary file. Ugh.
 
> Apparently you've never heard of a pipe? That says a lot for your
> programming.
 
What does pipe have to do with this? You can do IPC in all sorts of
ways...
 
 
--
press any key to continue or any other to quit...
Ian Collins <ian-news@hotmail.com>: May 19 10:19AM +1200

On 19/05/18 09:50, Vir Campestris wrote:
> Windows will guarantee that (except for HW fails) a page fault will
> work. You'll get the memory that is behind that page. It's not like *nix
> systems where overcommit and copy-on-write are common,
 
Sensible Unix systems do not use over-commit, it is a Linux specific
abomination.
 
--
Ian.
Sky89 <Sky89@sky68.com>: May 18 05:52PM -0400

Hello....
 
 
Read again, i correct a typo , because i write fast..
 
I come from Delphi and Freepascal, and i have looked at ADA, and
ADA is easy for me, i have done also some C++ , but C++ is "too"
weakly typed as i have explained in my previous posts, this is why i
love ADA, because ADA is more strongly typed than C++ or C , it looks
like Delphi and FreePascal. I love ADA because i love Delphi and FreePascal.
 
Here is my last invention for Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
 
You can find my other "inventions" and my other projects here:
 
https://sites.google.com/site/aminer68/
 
 
Thank youk,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 05:48PM -0400

Hello,
 
 
I come from Delphi and Freepascal, and i have looked at ADA, and
ADA is easy for me, i have done also some C++ , but C++ is "too"
weakly typed as i have explained in my previous posts, this is why i
love ADA, because ADA is more strongly than C++ or C , it looks like
Delphi and FreePascal. I love ADA because i love Delphi and FreePascal.
 
Here is my last invention for Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
 
You can find my other "inventions" and my other projects here:
 
https://sites.google.com/site/aminer68/
 
 
Thank youk,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 05:23PM -0400

Hello,
 
 
If you want to assign a negative signed variable to a positive unsigned
variable, this is possible in C++ and C.
 
And this is not possible in Delphi and FreePascal (with range checking
enabled) and it is not possible with ADA because they are strongly typed.
 
Also:
 
I have just tested C++ , and when i instantiate an object and i want to
assign the object to a variable, the C++ is weakly typed , so it can
assign a type of an object to another type of a variable, and this
is a big problem ! C++ has inherited this deficiency of being
"too" weakly typed from C, Delphi and FreePascal that i work with are
more strongly typed and they will not allow this problem to happen, ADA
too is strongly typed and it will not allow this problem to happen.
 
 
So from the above reasons i think that C++ and C are "too" permissive
and "too" weakly typed, they are more unsafe than ADA or Delphi or
FreePascal.
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 04:49PM -0400

Hello,
 
 
About the deficiency of C++
 
I have just tested C++ , and when i instantiate an object and i want to
assign the object to a variable, the C++ is weakly typed , so it can
assign a type of an object to another type of a variable, and this
is a big problem ! C++ has inherited this deficiency of being
"too" weakly typed from C, Delphi and FreePascal that i work with are
more strongly typed and they will not allow this problem to happen, ADA
too is strongly typed and it will not allow this problem to happen.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 04:05PM -0400

Hello..
 
 
A good book on C++:
 
Beginning C++17
From Novice to Professional
 
https://www.apress.com/us/book/9781484233658
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 03:37PM -0400

Hello..
 
 
C++ and Thoughts On Java, Go, and Rust:
 
https://eklitzke.org/c++-java-go-and-rust
 
 
 
Thank you,
Amine Moulay Ramdane.
Real Troll <Real.Troll@Trolls.com>: May 17 04:25PM -0400

>> Hello...
 
>> Here is how to use my Delphi projects with C++Builder:
> Is Delphi still used much?
 
Yes by that Moroccon nutter (some call him Moroccon terrorist) called
Sky89, Amine Moulay Ramdane, Ramine Moulay Ramdane, and some other nyms
he feels necessary to hide his identity.
 
Are you thinking of using it?
 
That Moroccon idiot spends all time releasing bug fixes for his toy
project. The fixes are released every 1 hour when he has stopped taking
his meds!!. Sometimes he is the only one on these newsgroups posting
his crap. Prolific trolls (like yours truly) haven't got a chance to
compete with him.
David Brown <david.brown@hesbynett.no>: May 18 10:04AM +0200

>> Hello...
 
>> Here is how to use my Delphi projects with C++Builder:
 
> Is Delphi still used much?
 
It is still used in many areas, but not nearly as popular as it was.
When Delphi 1.0 came out, it was state of the art for Windows software
development, Pascal (especially from Borland) was very common, and it's
only competitor for RAD on Windows was Visual Basic 3. These days,
Pascal has waned as a choice of development language, and there are
plenty of other RAD tools and choices for gui programming.
 
This particular poster, Amine, is obsessed with Delphi and his various
"scalable algorithms" implemented with it. He keeps posting to all
sorts of Usenet groups about them, with a total disregard for the
relevance. For all I know, he might actually be good at scalable
algorithms or have come up with bright new ideas, but he is such a weird
and an anti-social poster that no one takes him seriously enough to
bother to look at his stuff.
boltar@cylonHQ.com: May 18 08:39AM

On Fri, 18 May 2018 10:04:25 +0200
>algorithms or have come up with bright new ideas, but he is such a weird
>and an anti-social poster that no one takes him seriously enough to
>bother to look at his stuff.
 
I had a look at some of his stuff. If it is him who wrote it then he's
obviously very talented but I think its also not unfair to say he's probably
on the spectrum.
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: May 18 09:05AM +0200

Ref my efforts for a GUI options hierarchy back in 2010: <url:
http://www.drdobbs.com/cpp/pure-c-options-classes/224700827>
 
That solution was very complicated, using dirty template tricks.
 
Now I'm thinking about something like the following:
 
 
----------------------------------------------------------------------------
#include <utility> // std::pair
 
namespace my
{
using std::pair;
 
template< class Value, class Key >
struct Option_value
{
Value value;
 
Option_value() = default;
 
Option_value( Key, Value v )
: value( v )
{}
};
 
template< class Value, class Key >
auto opt( Key, Value value )
-> Option_value<Value, Key>
{ return {Key{}, value}; }
 
template< class Options, class Key, class Value >
auto operator|( Options& o, Option_value<Value, Key> value )
-> Options&
{
static_cast<Option_value<Value, Key>&>( o ) = value;
return o;
}
 
template< class Options, class Key, class Value >
auto operator|( Options&& o, Option_value<Key, Value> value )
-> Options&
{ return o | value; }
 
namespace impl
{
template< class Key, class Value >
auto value_type( Option_value<Value, Key> const& ) -> Value;
}
 
template< class Options, class Key >
auto opt_item( Key, Options const& o )
{
using Value = decltype( impl::value_type<Key>( o ) );
return static_cast<Option_value<Value, Key> const&>( o ).value;
}
 
} // namespace my
 
namespace tag
{
using Position = struct Position_tag_struct*;
using Speed = struct Speed_tag_struct*;
} // namespace tag
 
struct Base_options
: my::Option_value<int, tag::Position>
{
Base_options() = default;
};
 
struct Derived_options
: Base_options
, my::Option_value<int, tag::Speed>
{
Derived_options() = default;
};
 
#include <iostream>
auto main()
-> int
{
using namespace std;
using namespace tag;
using my::opt;
 
auto const o = Derived_options{} | opt(Position{}, 1) |
opt(Speed{}, 2);
cout << "Position " << opt_item( Position{}, o ) << endl;
cout << "Speed " << opt_item( Speed{}, o ) << endl;
}
----------------------------------------------------------------------------
 
 
I haven't tried it out in any GUI code yet, but it seems like it could
do the job.
 
Problems? Existing solutions?
 
 
Cheers!
 
- Alf
Sky89 <Sky89@sky68.com>: May 17 08:52PM -0400

Hello..
 
 
About political philosophy
 
I think you know me more today, that i have posted my political
philosophy here on this forum, and also that i am a more serious
computer programmer, today i will talk about an important subject,
i have said that political philosophy has as a prerequisite "order"
and being disciplined also needs "order", so we have to define
"order" , and in political philosophy we define "order" by
a priori pure moral inferred from "reason" and by empirical moral
inferred from "experience", but by a good approximation we can say that
today we have not to hate arabs, that's not a good thing to do, because
we have to "transcend" and "help" arabs to be better, China has to help
arabs to be better, and USA has to help arabs to be better and
Europe has to help arabs to be better, that's the right thing
to do, today for example we are fighting extremism and violence of ISIS,
but we have to do better than that , we have to help arabs to be better
at economy etc. to help them fight extremism and fight there problems.
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 17 07:35PM -0400

Hello,
 
 
My way of thinking..
 
It is like a scientist that wants to implement more mathematical tools
or the kind and that doesn't care about the best code factorization or
about the beautifulness of the code, i am like that , i am not a
software programmer, i have a university level diploma in
microelectronics and i have studied Turbo pascal and assembler when i
have studied for my Diploma in microelectronics and after that i have
learned Delphi that looks like Turbo pascal and i have learned C++ and
Java to implement my scalable algorithms and my software tools, and i
have learned operational research and i have learned more mathematics
and i have learned more computer science.
 
I am not a coder like you.
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 17 08:22PM -0400

Hello,
 
Read again, i correct a typo:
 
You have to know about political philosophy
 
What is the very important part of political philosophy ?
 
You can not call it political philosophy if it is not "order"
 
And you can not call it disciplined if it is not "order"
 
and "order" has to be defined more precisely by a priori moral
and by empirical moral.
 
If you start to "hate" arabs and hate others and hate our world, that's
not "order", and if there is no order over this planet that's dangerous.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 17 08:21PM -0400

Hello,
 
 
You have to know about political philosophy
 
What is the very important part of political philosophy ?
 
You can not call it political philosophy if it is not "order"
 
And you can not call it disciplined if it is not "order"
 
and "order" has to be defined more precisely by a priori moral
and by empirical moral.
 
If you start to "hate" arabs and hate others and hate our world, that's
not "order", and if there is no order over this planet that's dangerious.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 17 07:56PM -0400

Hello,
 
I am not wasting my time with Bonita Montero or with Real Troll of the
C++ forum that program in C# also , because by there way of insulting
and talking they are like handicaped people for me that i don't waste my
time with them, i am a more disciplined kind of person that is inventing
scalable algorithms and other software tools and porting them to Delphi
and FreePascal and C++ and Java, my last invention is this:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
Look at how it is a serious invention that makes you feel that it is
a serious piece of work, this is how i am in real life, i am more
disciplined and more morality.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 17 07:33PM -0400

Hello,
 
 
My way of thinking..
 
It is like a scientist that wants to implement more mathematical tools
or the kind and that doesn't care about the best code factorization or
about the beautifulness of the code, i am like that , i am not a
software programmer, i have a university level diploma in
microelectronics and i have studied Turbo pascal and assembler when i
have studied for my Diploma in microelectronics and after that i have
learned Delphi that looks like Turbo pascal and i have leaned C++ and
Java to implement my scalable algorithms and my software tools, and i
have learned operational research and i have learned more mathematics
and i have learned more computer science.
 
I am not a coder like you.
 
Thank you,
Amine Moulay Ramdane.
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.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)