Monday, January 25, 2016

Digest for comp.lang.c++@googlegroups.com - 9 updates in 4 topics

Jerry Stuckle <jstucklex@attglobal.net>: Jan 25 12:31PM -0500

On 1/25/2016 10:27 AM, Alf P. Steinbach wrote:
>> moved on.
 
> Not sure what you're talking about, it doesn't seem relevant to the
> context (quoted above).
 
Then read ALL of the quoted text - including "I am teaching C to
beginners, ..." and "It may be that these beginners do not know enough
to judge it."
 
> "BEST", which was short for "Building Enterprise Solutions and Testing".
> The nice thing about it was that it was first held in Nice, France. So I
> got a sort of paid holiday. :)
 
I hate to say this, but I know of two people who taught at the college
level and moved to corporate teaching. Neither one could teach C or C++
in a week and eventually failed. College instructors are good at
teaching when they have a whole semester to deal with, but these two
didn't so so well teaching the same material in five days.
 
 
> Namely, first that braces as such are not part of the structure, they
> are arbitrary symbol choices; and secondly, that the block structure is
> not a failure; and third, that it didn't stem from C but from Algol.
 
They are very much part of the syntactical structure. Whether they are
arbitrary symbol choices or not is immaterial; one could say '*' is an
"arbitrary symbol choice" for multiplications, for instance.
 
I never said the block structure was a failure; just that my students
never had a problem with the usage of braces. And they did stem from C;
C++ was built on C, starting with Stroustrups's first paper in the 70's
on "C with Objects". The fact C may have taken them from Algol is
immaterial; C++ is not built on Algol.
 
> corporation, either. For example. Are you seriously contending that
> Bjarne, creator of C++, did not know [2]what he was talking about in
> 1996? Jeez.
 
You snipped an important part here. I will remind you:
 
>>> stated that "I consider the C declaration syntax an experiment that
>>> failed".
 
>>> Surely the language creator must be considered an expert."
 
Bjarne Stroustup did not create C.
 
>>> [2] <url: http://www.stroustrup.com/cuj_interview.html>
 
> Cheers & hth., even though I couldn't make much sense of what you wrote,
 
> - Alf
 
It figures.
 
--
==================
Remove the "x" from my email address
Jerry Stuckle
jstucklex@attglobal.net
==================
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Jan 25 09:31PM +0100

On 1/25/2016 6:31 PM, Jerry Stuckle wrote:
> in a week and eventually failed. College instructors are good at
> teaching when they have a whole semester to deal with, but these two
> didn't so so well teaching the same material in five days.
 
You're right, I could certainly not teach C++ in a week.
 
I'm still learning, and as you may have surmised, I've used the language
since the early 1990s.
 
The facts and logic etc. that we dumb people who can't teach C++ in a
week, offer, must just be disregarded, ignored.
 
 
Cheers & hth.,
 
- Alf
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Jan 25 10:08PM +0100

On 1/25/2016 6:46 PM, Stefan Ram wrote:
 
> I wonder how those that say that it has failed would then
> prefer to declare f below, instead of
 
> int (*f(int (*)(long), int))(int, ...);
 
It's a good example of one aspect of the failure, that the syntax
doesn't work with the ordinary idea of substitution.
 
This failure aspect is what's caused the numerous questions from
learners about the syntax, and the ditto numerous web sites trying to
explain how to analyze and synthesize declarations.
 
Another aspect is that not all declarations can even be expressed
without naming some parts. Don't ask me for an example, I can't cough it
up, but I remember some SO questions about it, where I think mainly the
examples had to do with member functions. It's the most abject failure
ever, that the syntax can't even express all possibilities.
 
However, any good programmer would /name/ things, to enable substitution.
 
And I suspect that Bjarne would name the concrete types here, although
instead of C++11 trailing return type he'd probably use C++03 syntax:
 
using Arg_function = auto( long ) -> int;
using Referred_function = auto( int, ... ) -> int;
 
auto f( Arg_function*, int)
-> Referred_function*;
 
I would, since some months ago, also or alternatively use named type
builders, e.g., like this without naming any concrete types:
 
// In some header that's included:
template< class Some_type >
using Type_ = Some_type;
 
template< class Some_type >
using Ptr_ = Some_type*;
 
// Directly in one's own application code:
auto g( Ptr_<Type_<auto( long )->int>>, int)
-> Ptr_<Type_<auto( int,... )->int>>;
 
Not sure yet if that's so verbose that it defeats the purpose. It's
certainly, like the C syntax, so alien at first sight that it might look
incomprehensible! But at least it's directly readable, and works with
the substitution principle, neither of which the C syntax does.
 
 
> , or - for another example - p, instead of
 
> int *(*(*p)())[5]
 
Now you try it. :-)
 
 
> description of the syntax is called »grammar«. The
> grammar usually is given in the form of some variant
> of EBNF.
 
I'm sorry, my google-foo fails me. I shouldn't have mentioned it. Enough
with the Bjarne quote (he also considers exception specifications a
failure, and indeed they were removed), and the evidence of all the
questions and explanations, + your examples.
 
 
Cheers!,
 
- Alf
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Jan 25 11:18PM +0100

On 1/25/2016 10:08 PM, Alf P. Steinbach wrote:
> certainly, like the C syntax, so alien at first sight that it might look
> incomprehensible! But at least it's directly readable, and works with
> the substitution principle, neither of which the C syntax does.
 
Oh, I was stupid, all right.
 
That should instead be just
 
auto g( Ptr_<auto(long)->int>, int)
-> Ptr_<auto(int,...)->int>;
 
Or, taking advantage of automatic decay to pointer type, just
 
auto g( auto(long)->int, int)
-> Ptr_<auto(int,...)->int>;
 
But I feel that that last one is inconsistent in a way, when comparing
the formal argument type and the result type.
 
Anyway, no wonder I felt that the example I gave was too verbose!
Somehow I didn't notice the redundancy, I just mechanically, in a way,
translated from C syntax. Hm!
 
 
Cheers,
 
- Alf
Waqas Ahmed <waqas@gennextmovement.org>: Jan 25 01:46PM -0800

Greetings,
 
I am looking for technical sources for the following open positions. Please send me your resume at your earliest.
 
1: SQL Data Analyst | New York, NY

Requirements:
- Minimum of 2 years of experience in a data analyst role, with increasing levels of responsibility
- Advanced expertise in database operations and experience with SQL-based databases (e.g. SQL Server, MYSQL, Access, Greenplum, etc.) is a requirement for this role
- Experience working with large data sets of varying levels of structure
- Experience managing software development or other types of projects
- Superior analytical skills and demonstrated ability to break down large, complex business problems into discrete, achievable steps
- Broad experience in data quality and data processing
- Knowledge of data warehousing and data management processes
- Excellent verbal and written communication skills and demonstrated ability to communicate research findings to both technical and non-technical decision makers
- Data modeling experience is a plus
- Experience with market-leading data visualization software tools (e.g. QlikView, Tableau, Cognos, etc.) is a plus
- Experience with R or other statistical software tools is a plus


2: Core Financial Applications C++ Developer | New York, NY

Qualifications:
- 2+ years of software development experience in C/C++
- 2+ years of experience with object-oriented design, data structures, algorithms and all phases of the software development life cycle
- 2+ years of analytical and problem-solving skills

3: Foundational Applications C++ Developer | New York, NY
 
Qualifications:
- 3+ years of production-level development using C++ in Linux/UNIX environment
- 3+ years of experience with object-oriented design, data structures, algorithms and all phases of the software development life cycle

If you are not available / interested, please refer someone similar to your skill set.
 
Best regards,
Waqas Ahmed
ram@zedat.fu-berlin.de (Stefan Ram): Jan 25 05:46PM

>with the C User's Journal in 1996, Bjarne stated that ''I consider the C
>declaration syntax an experiment that failed''.
 
I wonder how those that say that it has failed would then
prefer to declare f below, instead of
 
int (*f(int (*)(long), int))(int, ...);
 
, or - for another example - p, instead of
 
int *(*(*p)())[5]
 
.
 
IIRC, Ritchie said about C something link »it's quite all right,
though some operators have the wrong precedence«.
 
Syntax, of course, is the set of all programs, while
semantics determine the meaning of a programs. The
description of the syntax is called »grammar«. The
grammar usually is given in the form of some variant
of EBNF.
ram@zedat.fu-berlin.de (Stefan Ram): Jan 25 06:16PM

>Syntax, of course, is the set of all programs, while
 
I made this up, but in good faith that it really is
a reasonable definition compatible with common usage.
 
Now, I looked it up. I did not found too many hits
for exactly this definition. But one hit should convey
the idea:
 
»A language is formally defined as: a syntax, which
defines the set of all valid programs in this language«
 
flint.cs.yale.edu/cs421/lectureNotes/Fall12/compcert-slides.pdf
 
However, I do not say that the syntax /defines/ this set,
but that it /is/ the set, and a text that /defines/ this set
I call a »grammar«.
 
And, I do not say »valid programs« but »programs«, because
I do not want to add the complication of a trichotomy between
 
- texts that are not programs;
- texts that are programs, but not valid programs; and
- texts that are valid programs.
 
I just want to tell texts that are programs from texts that
are not programs (dichotomy).
ram@zedat.fu-berlin.de (Stefan Ram): Jan 25 08:42PM

>I could certainly not teach C++ in a week.
 
One cannot teach C++ in a week, and one cannot teach C++
in one semester.
 
What one can teach is a selection of C++ (a subset of all
that one could say about C++).
 
The choice of that subset depends on several factors that
include the length of the course.
Paavo Helde <myfirstname@osa.pri.ee>: Jan 25 10:35PM +0200

On 25.01.2016 18:59, 嘱 Tiib wrote:
> if he writes 'void swap(Y&, Y&)' in his namespace X?
> So the 'using namespace std' serves as way to fall back to 'std::swap'
> if he for some reason did not write 'X::swap' despite he said he wants.
 
It's more for generic templated code where you have no idea if there is
any special swapping support defined for type T or not, but you still
want to swap T-s.
 
Cheers
Paavo
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)