473,320 Members | 2,027 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,320 software developers and data experts.

*** New C# Language V2.0 Specification Now Available ***

You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum
for the C# language on that same page.
If you don't own a copy of MS Word, you can download the free viewer at:

http://www.microsoft.com/downloads/d...displaylang=EN
--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
Nov 15 '05 #1
42 2123
Eric Gunnerson [MS] <er****@online.microsoft.com> wrote:
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum
for the C# language on that same page.


<snip>

Any word on when the other new features in C# are likely to be released
in a specification (draft or otherwise)? I'm looking forward to seeing
exactly how properties with different access modifiers for the accessor
and mutator are specified. (That and whether or not a property will be
able to define its own variables which aren't accessible outside the
property itself.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too
Nov 15 '05 #2
Is that the new spec or is it the new "draft" spec.........hmmmm

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...
Eric Gunnerson [MS] <er****@online.microsoft.com> wrote:
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum for the C# language on that same page.


<snip>

Any word on when the other new features in C# are likely to be released
in a specification (draft or otherwise)? I'm looking forward to seeing
exactly how properties with different access modifiers for the accessor
and mutator are specified. (That and whether or not a property will be
able to define its own variables which aren't accessible outside the
property itself.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

Nov 15 '05 #3
It's a draft . See the page's C# 2.0 Specification paragraph.

Willy.
"Jesse" <th***********@urnuts.com> wrote in message news:uS**************@TK2MSFTNGP11.phx.gbl...
Is that the new spec or is it the new "draft" spec.........hmmmm

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...
Eric Gunnerson [MS] <er****@online.microsoft.com> wrote:
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum for the C# language on that same page.


<snip>

Any word on when the other new features in C# are likely to be released
in a specification (draft or otherwise)? I'm looking forward to seeing
exactly how properties with different access modifiers for the accessor
and mutator are specified. (That and whether or not a property will be
able to define its own variables which aren't accessible outside the
property itself.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too


Nov 15 '05 #4
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:uh**************@TK2MSFTNGP09.phx.gbl...
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum
for the C# language on that same page.


I now have three C# language specs:

C# Language Specification (from Microsoft), dated 2001
ECMA-334, dated 2002
C# Language Specification v1.2, dated 2003

Where can I find descriptions of how they differ?
Nov 15 '05 #5
I don't like the verbose syntax "yield return" and "yield break". Why not
simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really be no
problem with code breaking. Even if someboy was so stupid to use "yield" as
identifier - this is quickly corrected, as yield is not reserved as class,
method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
Nov 15 '05 #6
Partials are just stupid, and anonymous methods, argue all you want about
spaghetti code, its still spaghetti code.

The only real gain from 2.0 is generics

Still doesnt fix all the gaps in libraries, how much time is wasted wrapping
things that should have been wrapped. how much of a typical project has to
end up going to native calls. Time wasted in my view.
"codymanix" <do*********************@gmx.de> wrote in message
news:OL**************@TK2MSFTNGP09.phx.gbl...
I don't like the verbose syntax "yield return" and "yield break". Why not
simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really be no problem with code breaking. Even if someboy was so stupid to use "yield" as identifier - this is quickly corrected, as yield is not reserved as class,
method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk

Nov 15 '05 #7
> Partials are just stupid

I have a bad feeling about them too but look into reality programming. Often
Forms-classes can get really huge and now imagine you are working in a team
and more than 1 programmer wants to work on that class. Additionally
automatically generated code can be separated from written code. Maybe they
aren't as bad when you once get used to them-
, and anonymous methods, argue all you want about
spaghetti code, its still spaghetti code.
It depends. Imagine you have 30 controls in one form and have to add a
eventhandler to each of them where the handling code is just a few lines
each time. Do you want to write 30 methods and make sure that each method
belongs to excact one handler and you don't left one out or want to define
the eventhandling methods where they are used?
The only real gain from 2.0 is generics
Indeed! No more stupid unneccessary casting!
Still doesnt fix all the gaps in libraries, how much time is wasted wrapping things that should have been wrapped. how much of a typical project has to end up going to native calls. Time wasted in my view.
..Net isn't a wrapper to the Windows API or to COM objects. It is a
independent platform (although it runs only on windows-how funny :) )
When you want to use functionality which is not part of .Net you have to use
Interop and build your own wrappers.

In my experience native calls are very rarely used. On which kind of
projects do you work where you need to many native stuff?
"codymanix" <do*********************@gmx.de> wrote in message
news:OL**************@TK2MSFTNGP09.phx.gbl...
I don't like the verbose syntax "yield return" and "yield break". Why not simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really be

no
problem with code breaking. Even if someboy was so stupid to use "yield"

as
identifier - this is quickly corrected, as yield is not reserved as class, method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.


--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
Nov 15 '05 #8
The first two should be identical, though the ECMA one has different
numbering.
The third one has some clarifications and updates, and a new introduction.

--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
"Mike Schilling" <ms*************@hotmail.com> wrote in message
news:eq**************@TK2MSFTNGP12.phx.gbl...
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:uh**************@TK2MSFTNGP09.phx.gbl...
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum for the C# language on that same page.


I now have three C# language specs:

C# Language Specification (from Microsoft), dated 2001
ECMA-334, dated 2002
C# Language Specification v1.2, dated 2003

Where can I find descriptions of how they differ?

Nov 15 '05 #9
We had originally used "yield" by itself, but unfortunately, that would
require us to add a new keyword to the language, which has the potential to
break current code. By using "yield return", we don't have to do this.

--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
"codymanix" <do*********************@gmx.de> wrote in message
news:OL**************@TK2MSFTNGP09.phx.gbl...
I don't like the verbose syntax "yield return" and "yield break". Why not
simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really be no problem with code breaking. Even if someboy was so stupid to use "yield" as identifier - this is quickly corrected, as yield is not reserved as class,
method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk

Nov 15 '05 #10


--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
Partials are just stupid
I have a bad feeling about them too but look into reality programming.

Often Forms-classes can get really huge and now imagine you are working in a team and more than 1 programmer wants to work on that class. Additionally
automatically generated code can be separated from written code. Maybe they aren't as bad when you once get used to them-


The big goal for partial classes *is* for generated code. Being able to keep
that separate from the user code simpifies the user model.

Nov 15 '05 #11
"news.microsoft.com" <an********@discussions.microsoft.com> wrote in
news:Of**************@tk2msftngp13.phx.gbl:
Partials are just stupid, and anonymous methods, argue all you want
about spaghetti code, its still spaghetti code.


Anonymous methods are indeed something I'll probably never use, but
Partial types are a thing that should have been present in v1.0 (as generics
should have been too). Partial types gives you the ability to separate
generated code from handwritten code, which is important for code generates,
something that will be used more and more. Even vs.net generates code for
you, which can now be separated from your own code (which is a plus IMHO).

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #12
Thats up to the wizard, I bet most dont, they currently (or should at
presnt) use #region and #endregion for marking uneditable code.

Look at the current usage of lambada functions on other languages, or rather
MISUSE.

"Frans Bouma" <pe******************@xs4all.nl> wrote in message
news:Xn********************************@207.46.248 .16...
"news.microsoft.com" <an********@discussions.microsoft.com> wrote in
news:Of**************@tk2msftngp13.phx.gbl:
Partials are just stupid, and anonymous methods, argue all you want
about spaghetti code, its still spaghetti code.
Anonymous methods are indeed something I'll probably never use, but
Partial types are a thing that should have been present in v1.0 (as

generics should have been too). Partial types gives you the ability to separate
generated code from handwritten code, which is important for code generates, something that will be used more and more. Even vs.net generates code for
you, which can now be separated from your own code (which is a plus IMHO).

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com

Nov 15 '05 #13
You should not overvalue code breaking - programmers who was really stupid
enough to use yield as identifier can quickly change that in their code
(That yield would be used as identifier later was known a long time). The
change will also *not* break already compiledd assemblies. In other
languages including C++ there was lots of keywords added, years after the
original specification of the language and there was not problem.

But I know lots of people (even in a few years) will hate this unneccessary
verbose and annoying syntax only because in the *very* early days somebody
decided that yield *could* *eventually* break some code written in the early
days of c#.

However, "yield return" or not, I don't understand why "yield break" is
neccessary as a simple "return" would do it perfectly. The meaning of return
is: The method ends here. You should preserve that..

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
"Eric Gunnerson [MS]" <er****@online.microsoft.com> schrieb im Newsbeitrag
news:uu**************@tk2msftngp13.phx.gbl...
We had originally used "yield" by itself, but unfortunately, that would
require us to add a new keyword to the language, which has the potential to break current code. By using "yield return", we don't have to do this.

--
Eric Gunnerson

"codymanix" <do*********************@gmx.de> wrote in message
news:OL**************@TK2MSFTNGP09.phx.gbl...
I don't like the verbose syntax "yield return" and "yield break". Why not simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really be

no
problem with code breaking. Even if someboy was so stupid to use "yield"

as
identifier - this is quickly corrected, as yield is not reserved as class, method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.

--
cody

Nov 15 '05 #14

"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
You should not overvalue code breaking - programmers who was really stupid
enough to use yield as identifier can quickly change that in their code
(That yield would be used as identifier later was known a long time). The
change will also *not* break already compiledd assemblies. In other
languages including C++ there was lots of keywords added, years after the
original specification of the language and there was not problem.

But how long, some code may be 2 or 3 years old by this point, I didn't hear
about yield likely being an identifier until about a year ago, maybe a
little longer. I don't know if some of my own code would break, not to
mention however millions of lines were written before anyone had any clue
that iterators would be a C# feature with the .NET 2.0 framework.
And as I recall, C\C++ reserved all names starting with __ or something to
that effect, so it was your fault if you screwed up, they told you
beforehand what not to use. I don't want to see C# take the approach of
prefixing keywords with __ (or any other sequence) just to maintain the
ability to add keywords. Add onto that the utter complexity of a C++ and a
C++ compiler, and I don't think that argument is worth much. C++ is maybe
too complex, has too many keywords, it does have an effect on C++ itself, if
not with the compiler then with the language itself, a concious decision to
avoid bloating the language is very important for C#.
But I know lots of people (even in a few years) will hate this unneccessary verbose and annoying syntax only because in the *very* early days somebody
decided that yield *could* *eventually* break some code written in the early days of c#.

I doubt it, its not a big deal and it maintains a simplier grammer, plus its
clearer, reserving a keyword really should be a last resort. If you are too
lazy to type yield return one time per iterator(twice maybe, I doubt it
would be much more than that), you really shouldn't be programming. Its
really not a big deal. However, even if yield could have been used as a
contextual statement, it would have confused people when used with yield
break, which I argue about below.
However, "yield return" or not, I don't understand why "yield break" is
neccessary as a simple "return" would do it perfectly. The meaning of return is: The method ends here. You should preserve that..

The meaning of return is NOT the method ends here, it means this CODE PATH
in this method ends here, here is the value you were interested in, or
atleast as close as I could get, it inessence returns a value from the
method, a return is not needed to end a method(however the langauge and
probably the runtime enforces it when there is a return type specified).
Blank returns are valid only in void methods where there is no return value
but in that case it is a syntatic nicety that makes logical sense, no value
to return, so return can stand alone. An iterator, on the other hande, does
have a return value, an enumerator or enumerable interface. A empty return
statement doesn't make sense, yield break does.
It keeps the complexity of the language grammer from growing to high, it
doesn't require changing the rules of return, which would be, by far, the
worst choice they could make.
--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
"Eric Gunnerson [MS]" <er****@online.microsoft.com> schrieb im Newsbeitrag
news:uu**************@tk2msftngp13.phx.gbl...
We had originally used "yield" by itself, but unfortunately, that would
require us to add a new keyword to the language, which has the potential

to
break current code. By using "yield return", we don't have to do this.

--
Eric Gunnerson

"codymanix" <do*********************@gmx.de> wrote in message
news:OL**************@TK2MSFTNGP09.phx.gbl...
I don't like the verbose syntax "yield return" and "yield break". Why not simply "yield" and "return"?

If someboy sees "return" he expects the end of the method. Why not
preserving this?

Yield is only reserved within iterator methods so there should really
be
no
problem with code breaking. Even if someboy was so stupid to use
"yield" as
identifier - this is quickly corrected, as yield is not reserved as

class, method, property-name, only locals would be affected and ONLY within
iterator methods! Already built assemblies are not affected.

--
cody


Nov 15 '05 #15
> Partials are just stupid

I couldn't disagree more. In our project, we have a class that's
approaching 7000 lines of code. This gets to be a problem when we have 2 or
3 people who want to work on the file at the same time. It'd be so much
easier with partials.
and anonymous methods, argue all you want about spaghetti
code, its still spaghetti code.


One practical application I see for anonymous methods is with dynamically
created forms. It would be possible to modify controls directly without
traversing the 'object sender' var passed in events. You also would not
have to have dynamically created forms events inside of other classes (where
they don't really belong anyway).
If you don't like the additions, nobody is saying you have to use them. You
clearly criticized them while only considering your own coding situation.

Chris Lajoie
Nov 15 '05 #16
Ofcourse I only consider my own coding situation, DUH.

"Chris LaJoie" <ch***@etriptrader.com> wrote in message
news:#K**************@TK2MSFTNGP09.phx.gbl...
Partials are just stupid
I couldn't disagree more. In our project, we have a class that's
approaching 7000 lines of code. This gets to be a problem when we have 2

or 3 people who want to work on the file at the same time. It'd be so much
easier with partials.
and anonymous methods, argue all you want about spaghetti
code, its still spaghetti code.
One practical application I see for anonymous methods is with dynamically
created forms. It would be possible to modify controls directly without
traversing the 'object sender' var passed in events. You also would not
have to have dynamically created forms events inside of other classes

(where they don't really belong anyway).
If you don't like the additions, nobody is saying you have to use them. You clearly criticized them while only considering your own coding situation.

Chris Lajoie

Nov 15 '05 #17
You dont need partials to redesign code (more like shuffle about the mess of
7000 lines).

"Chris LaJoie" <ch***@etriptrader.com> wrote in message
news:#K**************@TK2MSFTNGP09.phx.gbl...
Partials are just stupid
I couldn't disagree more. In our project, we have a class that's
approaching 7000 lines of code. This gets to be a problem when we have 2

or 3 people who want to work on the file at the same time. It'd be so much
easier with partials.
and anonymous methods, argue all you want about spaghetti
code, its still spaghetti code.
One practical application I see for anonymous methods is with dynamically
created forms. It would be possible to modify controls directly without
traversing the 'object sender' var passed in events. You also would not
have to have dynamically created forms events inside of other classes

(where they don't really belong anyway).
If you don't like the additions, nobody is saying you have to use them. You clearly criticized them while only considering your own coding situation.

Chris Lajoie

Nov 15 '05 #18
Chris LaJoie <ch***@etriptrader.com> wrote:
Partials are just stupid


I couldn't disagree more. In our project, we have a class that's
approaching 7000 lines of code. This gets to be a problem when we have 2 or
3 people who want to work on the file at the same time. It'd be so much
easier with partials.


That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would
increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too
Nov 15 '05 #19
"news.microsoft.com" <an********@discussions.microsoft.com> wrote in
news:#u*************@TK2MSFTNGP12.phx.gbl:
Thats up to the wizard, I bet most dont, they currently (or should at
presnt) use #region and #endregion for marking uneditable code.


THat's cludgy too. It also requires that the generator parses the
complete file.

I always found it a stupid idea of having 1 class per file. A class
is a concept you use to write code, why should it be bound to a concept that
has nothing to do with writing code: a file? The same stupidity as designing
an ORM model in Visio and then having to deal with a canvas that represents
A4 paper. Why? I'm designing it on the computer, not on paper.

Now, the class code can be developed in an IDE as a single unit and
stored in multiple 'buckets' (today they are files, tomorrow HOPEFULLY
elements directly inside a source control system or code database).

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #20
Jon Skeet [C# MVP] <sk***@pobox.com> wrote in
news:MP************************@msnews.microsoft.c om:
Chris LaJoie <ch***@etriptrader.com> wrote:
> Partials are just stupid


I couldn't disagree more. In our project, we have a class that's
approaching 7000 lines of code. This gets to be a problem when we have
2 or 3 people who want to work on the file at the same time. It'd be
so much easier with partials.


That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would
increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.


A class should be a logical element in the structure of the system.
Not a way to cut up code because a random person cooked up the idea that a
file of XYZ lines is too large. After all, cutting up a class in multiple
classes pollutes the class hierarchy with extra types that are hardly
different, creating extra problems when the types require each-others
data/logic (they were first stored in the same class, remember ;) ).

Although 7000 lines is a lot, you sometimes end up with large
classes, for example a main form class which controls all child windows
and main gui application logic (not the core application logic). It can
become very messy when you are chopping that up in smaller classes, which
will be used in just 1 spot: the main gui form, but because they're other
classes, you have add overhead code to communicate with them to reach
their data.

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #21
Frans Bouma <pe******************@xs4all.nl> wrote:
That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would
increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.
A class should be a logical element in the structure of the system.
Not a way to cut up code because a random person cooked up the idea that a
file of XYZ lines is too large. After all, cutting up a class in multiple
classes pollutes the class hierarchy with extra types that are hardly
different, creating extra problems when the types require each-others
data/logic (they were first stored in the same class, remember ;) ).


I agree that a class should be a logical element - but I've rarely seen
a single element of that many lines which isn't better broken down into
smaller subelements. That's not to say it should be done artificially,
of course.
Although 7000 lines is a lot, you sometimes end up with large
classes, for example a main form class which controls all child windows
and main gui application logic (not the core application logic). It can
become very messy when you are chopping that up in smaller classes, which
will be used in just 1 spot: the main gui form, but because they're other
classes, you have add overhead code to communicate with them to reach
their data.


If it controls *all* the child windows, I would have thought that would
be too much - each child window should have its own class, I'd imagine.
Maybe I'm misunderstanding you though.

For what it's worth, I've been in a similar situation with all the GUI
logic for a mobile web application being in one class (this was written
a few years ago). Having started down that road, it's very difficult to
refactor it into smaller classes (we've tried twice). If we'd started
off with the goal of factoring out different parts, I'm sure it
wouldn't have been too difficult though. (One of the main problems was
that it was originally going to be a small app, and then it grew much,
much bigger.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too
Nov 15 '05 #22
If you look at the BCLs you will see a huge deep inheratence tree. Also a
reason why we dont have multpile inheratance.

(never could spell that word too :D)

Im sure if you look more abstract at youre class you will see places you can
break it up or generalise and derive, try a little normalisation:D
"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...
Frans Bouma <pe******************@xs4all.nl> wrote:
That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.


A class should be a logical element in the structure of the system.
Not a way to cut up code because a random person cooked up the idea that a file of XYZ lines is too large. After all, cutting up a class in multiple classes pollutes the class hierarchy with extra types that are hardly
different, creating extra problems when the types require each-others
data/logic (they were first stored in the same class, remember ;) ).


I agree that a class should be a logical element - but I've rarely seen
a single element of that many lines which isn't better broken down into
smaller subelements. That's not to say it should be done artificially,
of course.
Although 7000 lines is a lot, you sometimes end up with large
classes, for example a main form class which controls all child windows
and main gui application logic (not the core application logic). It can
become very messy when you are chopping that up in smaller classes, which will be used in just 1 spot: the main gui form, but because they're other classes, you have add overhead code to communicate with them to reach
their data.


If it controls *all* the child windows, I would have thought that would
be too much - each child window should have its own class, I'd imagine.
Maybe I'm misunderstanding you though.

For what it's worth, I've been in a similar situation with all the GUI
logic for a mobile web application being in one class (this was written
a few years ago). Having started down that road, it's very difficult to
refactor it into smaller classes (we've tried twice). If we'd started
off with the goal of factoring out different parts, I'm sure it
wouldn't have been too difficult though. (One of the main problems was
that it was originally going to be a small app, and then it grew much,
much bigger.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

Nov 15 '05 #23
Jon Skeet [C# MVP] <sk***@pobox.com> wrote in
news:MP************************@msnews.microsoft.c om:
Frans Bouma <pe******************@xs4all.nl> wrote:
Although 7000 lines is a lot, you sometimes end up with large
classes, for example a main form class which controls all child windows
and main gui application logic (not the core application logic). It can
become very messy when you are chopping that up in smaller classes,
which will be used in just 1 spot: the main gui form, but because
they're other classes, you have add overhead code to communicate with
them to reach their data.
If it controls *all* the child windows, I would have thought that would
be too much - each child window should have its own class, I'd imagine.
Maybe I'm misunderstanding you though.


Child windows, for example in an MDI situation or docked inside the
main window, should control themselves, but say, the child window wants
something done in the application... where to put that logic, when yuo can
also start it from the menu for example... this will increase the main
form's code a lot and it's hard to chop it into multiple pieces because
you then end up with a lot of events, properties and other stuff that
wasn't even there in the beginning ;) exactly like you describe yourself:
For what it's worth, I've been in a similar situation with all the GUI
logic for a mobile web application being in one class (this was written
a few years ago). Having started down that road, it's very difficult to
refactor it into smaller classes (we've tried twice). If we'd started
off with the goal of factoring out different parts, I'm sure it
wouldn't have been too difficult though. (One of the main problems was
that it was originally going to be a small app, and then it grew much,
much bigger.)


That's what I ment :) But I agree that developers should write
classes that do a certain thing and not control the whole universe.
However it's sometimes hard to make the decision: add it to an existing
class or create a new class. Decisions like that in the early start of a
project can make the difference between a small set of large classes vs. a
large set of small classes.

FB
--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #24
Frans Bouma <pe******************@xs4all.nl> wrote:
That's what I ment :) But I agree that developers should write
classes that do a certain thing and not control the whole universe.
However it's sometimes hard to make the decision: add it to an existing
class or create a new class. Decisions like that in the early start of a
project can make the difference between a small set of large classes vs. a
large set of small classes.


Absolutely - but I'd usually prefer a large set of small classes, and I
*really* don't think that encouraging a small set of large classes is
something the language specification ought to be doing.

The main use of partial classes as far as I can see, however, is
keeping the machine-generated parts away from the human-generated
parts. That seems a perfectly reasonable thing to encourage.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too
Nov 15 '05 #25
Thanks, Eric. I don't suppose there's a list of changed sections anywhere,
or an MS Word diff tool I'm unaware of..

"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:OD**************@TK2MSFTNGP10.phx.gbl...
The first two should be identical, though the ECMA one has different
numbering.
The third one has some clarifications and updates, and a new introduction.

--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights. "Mike Schilling" <ms*************@hotmail.com> wrote in message
news:eq**************@TK2MSFTNGP12.phx.gbl...
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:uh**************@TK2MSFTNGP09.phx.gbl...
You may download the new specification at the C# Developer Center
(http://msdn.microsoft.com/vcsharp/language). There is a discussion forum for the C# language on that same page.


I now have three C# language specs:

C# Language Specification (from Microsoft), dated 2001
ECMA-334, dated 2002
C# Language Specification v1.2, dated 2003

Where can I find descriptions of how they differ?


Nov 15 '05 #26
> And as I recall, C\C++ reserved all names starting with __ or something to
that effect, so it was your fault if you screwed up, they told you
beforehand what not to use.


C++ added the keyword "mutable" (and others). There are no leading
underscores. I shit on breaking changes. The code is quickly corrected and
thats better than having to write ___mutable the next 30 years I use this
language!

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
Nov 15 '05 #27
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message news:<Oc**************@tk2msftngp13.phx.gbl>...
--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
Partials are just stupid


I have a bad feeling about them too but look into reality programming.

Often
Forms-classes can get really huge and now imagine you are working in a

team
and more than 1 programmer wants to work on that class. Additionally
automatically generated code can be separated from written code. Maybe

they
aren't as bad when you once get used to them-


The big goal for partial classes *is* for generated code. Being able to keep
that separate from the user code simpifies the user model.


Code generation is a work-around for bad languages and/or libraries.
If the language has sufficient power and libraries are well-designed
then there is little need to generate code. For example, you could
use Lex and YACC to generate C++ code, or you could use the SPIRIT
parser classes instead.
Nov 15 '05 #28
>That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would
increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.

I am not saying that there way of doing things is right or wrong. I can
definitely say I have written my share of crap code durin my 16 years a a
programmer, but I did hear someone say one time that if a class printout does
not fit on just one page, it is probably too long. :)

Nov 15 '05 #29

"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
And as I recall, C\C++ reserved all names starting with __ or something to that effect, so it was your fault if you screwed up, they told you
beforehand what not to use.
C++ added the keyword "mutable" (and others). There are no leading
underscores. I shit on breaking changes. The code is quickly corrected and
thats better than having to write ___mutable the next 30 years I use this
language!

Well, when it comes down to it, thats your problem. You are really far to
rude to actually achieve anything. But, anyway, adding a keyword when it has
to be added is one thing, in this case its not, no matter how much you want
to complain about it. --
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk

Nov 15 '05 #30
kc******@hotmail.com (Kevin Cline) wrote in
news:ba**************************@posting.google.c om:
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:<Oc**************@tk2msftngp13.phx.gbl>...
The big goal for partial classes *is* for generated code. Being able to
keep that separate from the user code simpifies the user model.


Code generation is a work-around for bad languages and/or libraries.
If the language has sufficient power and libraries are well-designed
then there is little need to generate code. For example, you could
use Lex and YACC to generate C++ code, or you could use the SPIRIT
parser classes instead.


haha :) So you type all your database access code by hand? Great
sense of productivity ;)

Lex and Yacc are tools to generate a parser. They use an abstract
input language to produce specialized code you could have written by hand
but that would take a lot of time.

Code generation is a mechanism to produce sourcecode you otherwise
had to type in by hand. True, you probably can design away some of it by
using patterns and class hierarchies, but I estimate not more than 50% of
what you have to write. That's at least 50% left to type in by hand. Now,
I don't know but when I have to chose between a click of a button to
produce that code or typing it all in by hand, I will opt for the button
click. However, perhaps you love typing repetitive code for hours and
hours, I don't know ;)

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #31
Kerry Sanders <di****@NOSPAMyahoo.com> wrote in
news:ga********************************@4ax.com:
That sounds like a really bad reason to use partial types, IMO. Is it
really not possible to refactor that code into more classes which would
increase the readability of the code to start with? I've only *very*
rarely seen classes which really deserve to be that long.

I am not saying that there way of doing things is right or wrong. I can
definitely say I have written my share of crap code durin my 16 years a
a programmer, but I did hear someone say one time that if a class
printout does not fit on just one page, it is probably too long. :)


Of course it's too long... for that piece of paper. ;)

Measurements of class aspects by using concepts like paper-size,
file amount or screen size are stupid. It's the functionality the class
represents, plus the data it encapsulates and represents. There is no
golden rule where to draw the line which says "at this point the class is
generic enough. Adding more will make it a big blob without a meaning".
Some will argue that that line comes very quickly, others have a different
opinion. (and the fun thing is, both sides think they're right, while
there is no rule which even defines the 'right' in this case) :)

FB, who once learned that a C function should fit on a 80x24 wyse
screen and if it was larger than that, the function was bad.

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #32
"Daniel O'Connell" <onyxkirx@--NOSPAM--comcast.net> schrieb im Newsbeitrag
news:B8jnb.44034$Tr4.91890@attbi_s03...

"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
And as I recall, C\C++ reserved all names starting with __ or
something
to that effect, so it was your fault if you screwed up, they told you
beforehand what not to use.
C++ added the keyword "mutable" (and others). There are no leading
underscores. I shit on breaking changes. The code is quickly corrected and thats better than having to write ___mutable the next 30 years I use this language!

Well, when it comes down to it, thats your problem. You are really far to
rude to actually achieve anything. But, anyway, adding a keyword when it

has to be added is one thing, in this case its not, no matter how much you want to complain about it.

Iam not rude. I simply disagree with the way they want to implement "yield"
and I do not understand why in C++ keywords was added tenth of year after
the initial version and a worldwide codebase of c++ code of gigabytes.

And in C# is in its very early days with small codebase and only two years
past since introduction they refuse to make such a small change even if the
likelyhood that some code gets broken is minimal and fixing that code is
small matter of programming.

When c# is now already in a state where no new keywords can be added what
will it be in 10 or more years?

--
cody

Freeware Tools, Games and Humour
http://www.deutronium.de.vu
[noncommercial and no fucking ads]
Nov 15 '05 #33
"cody" <de********@gmx.net> wrote in
news:uC**************@TK2MSFTNGP09.phx.gbl:
"Daniel O'Connell" <onyxkirx@--NOSPAM--comcast.net> schrieb im
Newsbeitrag news:B8jnb.44034$Tr4.91890@attbi_s03...
"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
> C++ added the keyword "mutable" (and others). There are no leading
> underscores. I shit on breaking changes. The code is quickly
> corrected and thats better than having to write ___mutable the next
> 30 years I use this language!

Well, when it comes down to it, thats your problem. You are really far
to rude to actually achieve anything. But, anyway, adding a keyword
when it has to be added is one thing, in this case its not, no matter
how much you want to complain about it.


Iam not rude. I simply disagree with the way they want to implement
"yield" and I do not understand why in C++ keywords was added tenth of
year after the initial version and a worldwide codebase of c++ code of
gigabytes.

And in C# is in its very early days with small codebase and only two
years past since introduction they refuse to make such a small change
even if the likelyhood that some code gets broken is minimal and fixing
that code is small matter of programming.

When c# is now already in a state where no new keywords can be added
what will it be in 10 or more years?


Cody, for what's worth, I fully agree with you. The masses of
developers still have to come to .NET, and by not adding keywords now but
a 'workaround' it will be regretted later and then it is much worse to add
keywords.

After all, only code that get's recompiled is affected, and can be
fixed easily by a global replace routine.

FB
--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #34

"cody" <de********@gmx.net> wrote in message
news:uC**************@TK2MSFTNGP09.phx.gbl...
"Daniel O'Connell" <onyxkirx@--NOSPAM--comcast.net> schrieb im Newsbeitrag
news:B8jnb.44034$Tr4.91890@attbi_s03...

"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
> And as I recall, C\C++ reserved all names starting with __ or something
to
> that effect, so it was your fault if you screwed up, they told you
> beforehand what not to use.

C++ added the keyword "mutable" (and others). There are no leading
underscores. I shit on breaking changes. The code is quickly corrected and thats better than having to write ___mutable the next 30 years I use this language!
Well, when it comes down to it, thats your problem. You are really far

to rude to actually achieve anything. But, anyway, adding a keyword when it

has
to be added is one thing, in this case its not, no matter how much you

want
to complain about it.

Iam not rude. I simply disagree with the way they want to implement

"yield" and I do not understand why in C++ keywords was added tenth of year after
the initial version and a worldwide codebase of c++ code of gigabytes.

And in C# is in its very early days with small codebase and only two years
past since introduction they refuse to make such a small change even if the likelyhood that some code gets broken is minimal and fixing that code is
small matter of programming.

When c# is now already in a state where no new keywords can be added what
will it be in 10 or more years?
Anyone that speaks like you, and I quote, "I shit on breaking changes" is
rude. --
cody

Freeware Tools, Games and Humour
http://www.deutronium.de.vu
[noncommercial and no fucking ads]

Nov 15 '05 #35

"Frans Bouma" <pe******************@xs4all.nl> wrote in message
news:Xn*********************************@207.46.24 8.16...
"cody" <de********@gmx.net> wrote in
news:uC**************@TK2MSFTNGP09.phx.gbl:
"Daniel O'Connell" <onyxkirx@--NOSPAM--comcast.net> schrieb im
Newsbeitrag news:B8jnb.44034$Tr4.91890@attbi_s03...
"cody" <do*********************@gmx.de> wrote in message
news:bn*************@ID-176797.news.uni-berlin.de...
> C++ added the keyword "mutable" (and others). There are no leading
> underscores. I shit on breaking changes. The code is quickly
> corrected and thats better than having to write ___mutable the next
> 30 years I use this language!
Well, when it comes down to it, thats your problem. You are really far
to rude to actually achieve anything. But, anyway, adding a keyword
when it has to be added is one thing, in this case its not, no matter
how much you want to complain about it.
Iam not rude. I simply disagree with the way they want to implement
"yield" and I do not understand why in C++ keywords was added tenth of
year after the initial version and a worldwide codebase of c++ code of
gigabytes.

And in C# is in its very early days with small codebase and only two
years past since introduction they refuse to make such a small change
even if the likelyhood that some code gets broken is minimal and fixing
that code is small matter of programming.

When c# is now already in a state where no new keywords can be added
what will it be in 10 or more years?


Cody, for what's worth, I fully agree with you. The masses of
developers still have to come to .NET, and by not adding keywords now but
a 'workaround' it will be regretted later and then it is much worse to add
keywords.

After all, only code that get's recompiled is affected, and can be
fixed easily by a global replace routine.


While I agree that the strange syntax is weird, I do not think using return
in this case is proper, furthermore that is a hacky work around if I've ever
seen one, far worse than context keywords. Changing the meaning of return in
one circumstance is a very very bad thing and I think it would confuse
people more than using context sensitive wording.
FB
--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com

Nov 15 '05 #36
> Measurements of class aspects by using concepts like paper-size,
file amount or screen size are stupid. It's the functionality the class
represents, plus the data it encapsulates and represents. There is no


Opinions. I understand your class represents the functionality that you need.
I just made a funny observation that someone said to me a long time ago. No
need for you to take it personally.

Or course, the 7000 lines of code is your code and you are the one that has to
work on it. I am glad it isn't me.

Nov 15 '05 #37
7000 likes comprising or /// and /* */ blocks :D how much is dead code :D
how much is actualy used, man i bet the JIT on that takes a while.

--
-----------
Got TidBits?
Get it here: www.networkip.net/tidbits
"Kerry Sanders" <di****@NOSPAMyahoo.com> wrote in message
news:ed********************************@4ax.com...
Measurements of class aspects by using concepts like paper-size,
file amount or screen size are stupid. It's the functionality the class
represents, plus the data it encapsulates and represents. There is no
Opinions. I understand your class represents the functionality that you

need. I just made a funny observation that someone said to me a long time ago. No need for you to take it personally.

Or course, the 7000 lines of code is your code and you are the one that has to work on it. I am glad it isn't me.

Nov 15 '05 #38
Kerry Sanders <di****@NOSPAMyahoo.com> wrote in
news:ed********************************@4ax.com:
Measurements of class aspects by using concepts like
paper-size,
file amount or screen size are stupid. It's the functionality the class
represents, plus the data it encapsulates and represents. There is no
Opinions. I understand your class represents the functionality that you
need. I just made a funny observation that someone said to me a long
time ago. No need for you to take it personally.


Who said it was personal? I read your comment, and perhaps it was
funny to you, I heard that remark as a serious remark mentioned to novice
developers (not me) a lot, and not as a funny remark. That's also why I
mentioned the 'has to fit on screen', quote, which is funny today, but was
hard reality in those days.

Nevertheless, I read several comments in this thread about the
class that is 7000 lines long. My project explorer window class in LLBLGen
Pro is 3116 lines long. That's 3116 lines of eventhandlers, management
code for the form and its controls (treeview etc), a lot of context menu
manager routines and handlers and properties. NO Application logic
whatsoever, that's placed in an assembly in a lower tier. True, I could
have subclassed the treeview and place logic there. However that would add
ANOTHER layer to the event chain running from the treeview's context menus
to the main gui the project explorer is docked in. What fun :) (and it
doesn't decrease complexity, which is the real reason a lot of lines is
not preferable: when you use a lot of classes you can abstract away some
code, however when abstracting away code snippet ABC increases complexity
because housekeeping event handlers have to be added, it doesn't help a
lot ;) )

Just an example how code can grow. Crying fool how crap a class
must be when it is 7000 lines long is moronic. Doing so shows you haven't
programmed complex gui's in .NET. True, when you want, you can group every
set of controls in a new control and hide the code in there, which will
lower the # of lines in the beginning, but will bite you in the foot when
overall application behaviour has to be kept in sync.

I'm sorry, but joking around about a guy's 7000 lines class is out
of order until you've seen the code yourself.
Or course, the 7000 lines of code is your code and you are the one that
has to work on it. I am glad it isn't me.


It wasn't me with the class of 7000 lines. However starting to
throw mud on the guy who had that class is zealotery: "Look, I know how to
design OO hierarchies, you're hierarchy stinks". As I said: measurements
of correct class size based on whatever measurement is pretty bogus: it's
one way or the other: a big class with not a lot of overhead code or a
large set of small classes with a lot of overhead code. What the most
optimal situation is between the two is not determinable by looking at the
class size, because what law proves that that measurement is the golden
rule? Nothing.

7000 is a lot of lines, however it can also have a lot of methods,
a lot of comments. I have classes which have a couple of thousand lines.
Most of these classes are not about a data element and the code targeting
that data element, but a group of functionality in one spot, like a
database driver or a main-form gui manager. Why would I have to chop it up
into more than one class? And better: what should be used as a dividing
rule what goes where? Chopping up classes can be good, but when there is
NO THEORY behind it, it's the most stupid thing a person can do: it will
increase the overhead in your application and if you're not careful it
will do that on a dramatic scale.

When you have a complex GUI which tries to keep everything in sync
(try to start thinking about the logic you need when you have an element
in your gui which name is shown in tabs, treeviews, controls, window
headers etc. that's eventhandler galore and a lot of code.) classes grow
out of proportion, classes can grow then beyond an amount of lines some
people find 'disgusting' or 'crappy design'. I can tell you: I've spend a
lot of time refactoring my GUI classes to make them smaller, however at
some point it isn't worth the effort, simply because chopping them up will
only create bigger classes.

Also, some program very verbose. I add a lot of commentlines, add a
lot of small methods and they all have XML comment tags, I also use a lot
of whitespace. This will add a lot of lines extra.

Don't forget that classes are logical, semantical boundaries of
code. It's simply stupid to divide a logical, semantical unit into two or
more classes simply someone says hte amount of lines is beyond a scale no-
one knows if its true or not. Again a reason why critizing a guy's 7000
lines class (which you do, don't forget that) is, sorry, a lame thing to
do, who says you are better than he is and your code is better than his?
Perhaps you would have ended up with also a 7000 line class as he did.
(imagine a form with a tabcontrol with a lot of tabs and a lot of code to
keep that working the way it should, that's a lot of overhead code you
can't abstract away).

Just a FYI.

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #39
"Alvin Bruney" <vapordan_spam_me_not@hotmail_no_spamhotmail.com > wrote in
news:O0**************@TK2MSFTNGP10.phx.gbl:
7000 likes comprising or /// and /* */ blocks :D how much is dead code
:D how much is actualy used, man i bet the JIT on that takes a while.


A method of 7000 lines will indeed take a while (or better: will not
/ never be jitted). A class with 500 small methods can be jitted perfectly,
as the jit jits methods on the fly, not just a whole class when it is
loaded.

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
Nov 15 '05 #40
Ignore this idiot. He is spoofing my email account.

--
-----------
Got TidBits?
Get it here: www.networkip.net/tidbits
"Alvin Bruney" <vapordan_spam_me_not@hotmail_no_spamhotmail.com > wrote in
message news:O0**************@TK2MSFTNGP10.phx.gbl...
7000 likes comprising or /// and /* */ blocks :D how much is dead code :D
how much is actualy used, man i bet the JIT on that takes a while.

--
-----------
Got TidBits?
Get it here: www.networkip.net/tidbits
"Kerry Sanders" <di****@NOSPAMyahoo.com> wrote in message
news:ed********************************@4ax.com...
Measurements of class aspects by using concepts like paper-size,
file amount or screen size are stupid. It's the functionality the class
represents, plus the data it encapsulates and represents. There is no


Opinions. I understand your class represents the functionality that you

need.
I just made a funny observation that someone said to me a long time ago.

No
need for you to take it personally.

Or course, the 7000 lines of code is your code and you are the one that

has to
work on it. I am glad it isn't me.


Nov 15 '05 #41
> Anyone that speaks like you, and I quote, "I shit on breaking changes" is
rude.

Maybe I sounded like beeing rude but I wasn't rude :)

--
cody

[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
Nov 15 '05 #42
Frans Bouma <pe******************@xs4all.nl> wrote in message news:<Xn*********************************@207.46.2 48.16>...
kc******@hotmail.com (Kevin Cline) wrote in
news:ba**************************@posting.google.c om:
"Eric Gunnerson [MS]" <er****@online.microsoft.com> wrote in message
news:<Oc**************@tk2msftngp13.phx.gbl>...
The big goal for partial classes *is* for generated code. Being able to
keep that separate from the user code simpifies the user model.
Code generation is a work-around for bad languages and/or libraries.
If the language has sufficient power and libraries are well-designed
then there is little need to generate code. For example, you could
use Lex and YACC to generate C++ code, or you could use the SPIRIT
parser classes instead.


haha :) So you type all your database access code by hand? Great
sense of productivity ;)


So SQL sucks. No need for C# to suck too.

Lex and Yacc are tools to generate a parser. They use an abstract
input language to produce specialized code you could have written by hand
but that would take a lot of time.

Code generation is a mechanism to produce sourcecode you otherwise
had to type in by hand. True, you probably can design away some of it by
using patterns and class hierarchies, but I estimate not more than 50% of
what you have to write.
Depends on the language. With a good language, you can eliminate
almost
all the redundant code and supply only the relevant information.
That's at least 50% left to type in by hand. Now,
I don't know but when I have to chose between a click of a button to
produce that code or typing it all in by hand, I will opt for the button
click. However, perhaps you love typing repetitive code for hours and
hours, I don't know ;)


You can reduce labor by wrapping source code patterns up in some
magic, and generally undocumented code generator, forever tying your
application to some IDE, or you can wrap that same source code into a
high-level object library.

And when the code generator won't generate the code you want, you're
stuck.

Besides, we're not really talking about code generators like lex and
yacc,
which are really language compilers. We're talking about generating
part
of a class through some IDE. Instead of creating ever more
complicated IDE's,
it would be better to create ever more powerful libraries.
Nov 15 '05 #43

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

1
by: Andrew James | last post by:
Gentlemen, I'm currently in the process of designing a language which will be used to specify sets of files on a WebDAV server, encoded in a URL. The aims of the language are to (in no particular...
7
by: Erwin Moller | last post by:
Hi group, I am a bit cconfused with the different tags I encounter to start a script. I used to use: language="Javascript" Nowadays I use: type="text/javascript" I did see some...
22
by: Vincent | last post by:
I would like to develop a site that should be available in several languages, say English, French and German. My question is: how can I suggest browsers of visitors to display the correct language...
63
by: Tristan Miller | last post by:
Greetings. Do any popular browsers correctly support <q>, at least for Western languages? I've noticed that Mozilla uses the standard English double-quote character, ", regardless of the lang...
2
by: Thomas G. Marshall | last post by:
Arthur J. O'Dwyer <ajo@nospam.andrew.cmu.edu> coughed up the following: > On Thu, 1 Jul 2004, Thomas G. Marshall wrote: >> >> Aside: I've looked repeatedly in google and for some reason cannot >>...
86
by: Randy Yates | last post by:
In Harbison and Steele's text (fourth edition, p.111) it is stated, The C language does not specify the range of integers that the integral types will represent, except ot say that type int may...
134
by: evolnet.regular | last post by:
I've been utilising C for lots of small and a few medium-sized personal projects over the course of the past decade, and I've realised lately just how little progress it's made since then. I've...
0
by: Marshal [DirectX MVP 2003] | last post by:
In anticipation of the chat, I have filtered all of my current enhancement aleration ideas through the software development community, via the following postings: C# Language Specification -...
23
by: Xah Lee | last post by:
The Concepts and Confusions of Pre-fix, In-fix, Post-fix and Fully Functional Notations Xah Lee, 2006-03-15 Let me summarize: The LISP notation, is a functional notation, and is not a...
0
by: DolphinDB | last post by:
Tired of spending countless mintues downsampling your data? Look no further! In this article, you’ll learn how to efficiently downsample 6.48 billion high-frequency records to 61 million...
0
by: ryjfgjl | last post by:
ExcelToDatabase: batch import excel into database automatically...
0
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
1
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
0
by: jfyes | last post by:
As a hardware engineer, after seeing that CEIWEI recently released a new tool for Modbus RTU Over TCP/UDP filtering and monitoring, I actively went to its official website to take a look. It turned...
1
by: PapaRatzi | last post by:
Hello, I am teaching myself MS Access forms design and Visual Basic. I've created a table to capture a list of Top 30 singles and forms to capture new entries. The final step is a form (unbound)...
1
by: Defcon1945 | last post by:
I'm trying to learn Python using Pycharm but import shutil doesn't work
0
by: af34tf | last post by:
Hi Guys, I have a domain whose name is BytesLimited.com, and I want to sell it. Does anyone know about platforms that allow me to list my domain in auction for free. Thank you
0
by: Faith0G | last post by:
I am starting a new it consulting business and it's been a while since I setup a new website. Is wordpress still the best web based software for hosting a 5 page website? The webpages will be...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.