www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - =?UTF-8?B?RCBmZWF0dXJlcw==?=

reply =?UTF-8?B?UmlzaGF0IEdhbGl1bGlu?= <rishatgaliulin mail.ru> writes:
SSdtIG5ld2JpZSB0byBELCBidXQgSSd2ZSBiZWVuIHdvbmRlcmVkIGJ5IGl0cyBmZWF0dXJlcy4K
CkkgaGF2ZSBzb21lIHF1ZXN0aW9ucyBhYm91dCBEMiBhbmQgaXRzIHN0YW5kYXJkIGxpYnJhcnkg
OgoxKSBXaHkgaXMgIk9iamVjdC5mYWN0b3J5KHN0cmluZyBjbGFzc25hbWUpIiBub3QgYWxsb3dp
bmcgdG8gY3JlYXRlIG9iamVjdHMgd2l0aG91dCBkZWZhdWx0IGNvbnN0cnVjdG9yLCBmb3IgZXhh
bXBsZToKICAgICB1Ynl0ZVtdIGFycmF5ID0gbmV3IHVieXRlWzEwXTsKICAgICBNeUNsYXNzIG15
ID0gT2JqZWN0LmZhY3RvcnkoIk15Q2xhc3MiLCAgYXJyYXkpOwoyKSBXaHkgRCBub3QgdXNpbmcg
ZnVuY3Rpb25zIGV4Y2VwdGlvbnMgc3BlY2lmaWNhdGlvbiBsaXN0IGxpa2UgSmF2YT8gSWYgdGhp
cyBwcm9tb3RlcyBiYWQgcHJvZ3JhbW1pbmcgc3R5bGUgdG8gbmV3YmllcywgbWF5IGJlIGJldHRl
ciBhdCBsZWFzdCB0byBjcmVhdGUgY29tcGlsYXRpb24gd2FybmluZ3M/CgpXaXRoIGJlc3QgcmVn
YXJkcywgUmlzaGF0IEdhbGl1bGluLg==
Sep 20 2011
next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 20 Sep 2011 15:58:06 -0400, Rishat Galiulin  
<rishatgaliulin mail.ru> wrote:

 I'm newbie to D, but I've been wondered by its features.

Welcome!
 I have some questions about D2 and its standard library :
 1) Why is "Object.factory(string classname)" not allowing to create  
 objects without default constructor, for example:
      ubyte[] array = new ubyte[10];
      MyClass my = Object.factory("MyClass",  array);

D does not have a very large run time reflection capability. Object.factory and the TypeInfo system is pretty much it. The theory is that with vastly superior compile-time reflection, the need for runtime reflection is either obviated or can be built using compile-time reflection. I think in fact an older library (flectioned) was built using this theory, but I've never used it, and it probably needs some dusting.
 2) Why D not using functions exceptions specification list like Java? If  
 this promotes bad programming style to newbies, may be better at least  
 to create compilation warnings?

Not sure what the question is, D does not support exception specification because exception specifications are too cumbersome to be useful. However, it does support saying that a function does *not* throw exceptions via the nothrow attribute. -Steve
Sep 20 2011
parent Walter Bright <newshound2 digitalmars.com> writes:
On 9/20/2011 2:28 PM, Jonathan M Davis wrote:
 On Tue, 20 Sep 2011 15:58:06 -0400, Rishat Galiulin
 2) Why D not using functions exceptions specification list like Java?



Bruce Eckel's article about it convinced me. http://www.mindview.net/Etc/Discussions/CheckedExceptions
Sep 20 2011
prev sibling next sibling parent "Jonathan M Davis" <jmdavisProg gmx.com> writes:
On Tuesday, September 20, 2011 14:02 Steven Schveighoffer wrote:
 On Tue, 20 Sep 2011 15:58:06 -0400, Rishat Galiulin
 2) Why D not using functions exceptions specification list like Java? If
 this promotes bad programming style to newbies, may be better at least
 to create compilation warnings?

Not sure what the question is, D does not support exception specification because exception specifications are too cumbersome to be useful. However, it does support saying that a function does *not* throw exceptions via the nothrow attribute.

Checked exceptions have generally been determined to have been a bad idea. They _seem_ like a good idea at first and do provide a number of benefits, but there are ultimately a number of problems with them. Java is the only language that I'm aware of that has checked exceptions. Both C# and D decided that they weren't a good idea and don't have them. This interview with one of the designers of C# gives some insight into the issues with checked exceptions: http://www.artima.com/intv/handcuffs.html Ultimately, it means that documentation needs to be clear about what exceptions something is expected to throw, and it does mean that it can be harder to make sure that your code is prepared for every exception type that it should be without catching Exception, but it still works quite well. Ideally, we'd have something that would statically verify that all of the appropriate exception types have been handled, but as far as I know, no one has really come up with a way to do that which doesn't have the problems that checked exceptions do. - Jonathan M Davis
Sep 20 2011
prev sibling next sibling parent Jacob Carlborg <doob me.com> writes:
On 2011-09-20 21:58, Rishat Galiulin wrote:
 I'm newbie to D, but I've been wondered by its features.

 I have some questions about D2 and its standard library :
 1) Why is "Object.factory(string classname)" not allowing to create objects
without default constructor, for example:
       ubyte[] array = new ubyte[10];
       MyClass my = Object.factory("MyClass",  array);

Have a look at: https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L486 It lets you create a new instance from a string regardless of the constructor, but it won't call the constructor. You might be able to use this incomplete function: https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L406
 2) Why D not using functions exceptions specification list like Java? If this
promotes bad programming style to newbies, may be better at least to create
compilation warnings?

 With best regards, Rishat Galiulin.

-- /Jacob Carlborg
Sep 20 2011
prev sibling parent "Marco Leise" <Marco.Leise gmx.de> writes:
Am 21.09.2011, 01:20 Uhr, schrieb Walter Bright  
<newshound2 digitalmars.com>:

 On 9/20/2011 2:28 PM, Jonathan M Davis wrote:
 On Tue, 20 Sep 2011 15:58:06 -0400, Rishat Galiulin
 2) Why D not using functions exceptions specification list like Java?


idea.

Bruce Eckel's article about it convinced me. http://www.mindview.net/Etc/Discussions/CheckedExceptions

I don't find this article all that convincing. The symptom is that people begin to write stub exception handlers and 'swallow' the exception. And this is seen as proof of a failed concept. I wrote exception stubs myself in the past. Mainly because I had to compile the program first to see the error, then write the proper exception handler or write a throw clause. That is cumbersome and you tend to just write a stub at the lowest level in your code, because it is less typing. Checked exceptions have the purpose to inform the program of invalid conditions in areas outside the immediate control of the program. In a released program you should take care of those one way or another, because it is likely that a host name cannot be resolved, or a file cannot be read (down to the fact that the disk has bad sectors). So you are made aware of this and must solve the problem in one of three ways, depending on the code structure: - add a throws clause to let the next higher level handle it - catch and handle it right there - do both - wrap the exception (if it happened in the subprocess of something bigger) It is a bit of a motivation to write actual error handlers, that you can easily forget otherwise. One of the reasons Java is popular is because of the great tools support. I am a big fan of Eclipse and if you have a look at the situation there you notice 1. try {...} catch (SomeKindOfException e) {} will mark the empty braces and print a warning about an undocumented empty block 2. Uncaught checked exceptions will show up as an error while you are typing 3. For these errors and many others there are 'quick-fixes'. You just press Ctrl+1 and choose a) add throws clause to method b) surround by try-catch 3b will add a stub like this: } catch (ExceptionType e) { e.printStackTrace(); } This means that no Exception actually goes unnoticed anymore as described in the article! It is plain no point today in Java. :) I guess one can say "they hack around the flaws in the language, you need an IDE to even use it properly" or one can say "they learned and found a way to make a good idea just work". For D there is no such IDE and all language features must promote good code when written in programming editors, Java can excuse a lot in that aspect.
Sep 22 2011