[lang]

classic Classic list List threaded Threaded
28 messages Options
12
Reply | Threaded
Open this post in threaded view
|

Re: [lang]

Ralph Goers
I have to say that if you look at the JDK for examples of how to code Java correctly you will be disappointed.  There are lots and lots of classes that are really bad.

Ralph


On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:

> This is not a matter of law. If Oracle/Sun set a direction on how to use
> NPE, it's a really good idea to follow them -- even if you don't agree, do
> it for the sake of consistency. I don't think using IAE is somehow "better"
> Java than what they are doing. And I give weight to what Joshua said
> because he's a former architect of that company. Lang3 was designed to
> throw NPE on invalid null arguments because that's what the gurus, like he,
> in our industry who publish "best practices" say it should. If your opinion
> bears greater weight than those set forth the best practices, then you win,
> but I don't advocate going back to IAE for nulls for the reasons stated.
>
>
>
>
> Cheers,
> Paul
>
>
> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]> wrote:
>
>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>
>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>
>>>> Hi Thiago,
>>>>
>>>>
>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>
>>>>> Hello people,
>>>>>
>>>>> Analizing the JIRA issue
>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>> contributors noticed that NumberUtils.max/min methods all have the same
>>>>> problem:
>>>>> They all throw an IllegalArgumentException when according to the
>> official
>>>>> documentation (Oracle|Sun) says that a NullPointerException must be
>> thrown
>>>>> when an argument must not be null.
>>>>>
>>>>
>>>> This is not a problem imho. It is a question of API design. I don't now
>> an
>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>> Sun/Oracle
>>>> at some point decided to throw NPE when ever a null reference is passed
>> to
>>>> a method that doesn't accept null inputs. I don't feel this is right,
>> since
>>>> a null input is also an illegal argument. Why make a differenciation?
>> IMHO
>>>> NPE should be reserved to the JVM, when a method is called on a null
>>>> reference, but that's just my opinion.
>>>
>>>
>>> It *is* a problem because NullPointerException and
>> IllegalArgumentException have concrete semantics layed out in the JDK's
>> Javadocs. If you see how both are used in the JDK, you see that NPE and IAE
>> are used properly and there is no such restriction to the JDK only. If you
>> aread Effective Java, you'll see that you *have to* use NPE if a null
>> argument is passed. One might remember the NullArgumentException back in
>> Lang 2, it was removed because it is imperative to use NPE instead.
>>
>> Effective Java is a great book, but don't confuse Joshua's advice with law.
>>
>>>
>>> Moreover, the Lang 3 package includes a great class, Validate, which does
>> things right and now I can ask, why the hell is that not used throughout
>> the entire library?
>>
>> +1 to this. We should update all of lang to use Validate once we've nailed
>> this issue.
>>
>> Duncan
>>
>>>
>>>
>>>>> However according to Apache Commons Lang Developer Guide, these methods
>> are
>>>>> all correct. This guide says that "When throwing an exception to
>> indicate a
>>>>> bad argument, always try to throw IllegalArgumentException, even if the
>>>>> argument was null. Do not throw NullPointerException.".
>>>
>>>
>>> Correct to the dev guide only -- not Java.
>>>
>>>
>>>> Since [lang] is currently designed this way, I'd rather deal with this
>>>> issue for 4.0. We can then revisit our initial decision to only throw
>> IAE
>>>> an maybe align it to what the JDK now does. If you want to file an
>> issue,
>>>> my opinion is, that it should be fix version 4.0. Changing the
>> exceptions
>>>> that are thrown now may break clients (although I think there are very
>> few
>>>> use cases where one should catch IAE or NPE).
>>>
>>>
>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>> indicate a programming error in the client not adhering to the contract
>> depicted by the Javadocs, so it is the client's problem to deal with them.
>> With proper programming, you should not have to catch those exception at
>> all.
>>>
>>>
>>>>> This mail was sent in order to discuss around and make decisions to
>> solve
>>>>> this dilemma where the Java official specification says X and the
>> Apache
>>>>> official specification says Y.
>>>>>
>>>>
>>>> Can you please provide a lnk to the official specification you're
>> refering
>>>> to? ;-)
>>>
>>>
>>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
>> issue.
>>>
>>> Further good resources:
>>>
>>> 1.
>>
>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html
>>> 2.
>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html:
>> "One case where it is common practice to throw a RuntimeException is when
>> the user calls a method incorrectly. For example, a method can check if one
>> of its arguments is incorrectly null. If an argument is null, the method
>> might throw a NullPointerException, which is an unchecked exception."
>>>
>>> Michael
>>>
>>>
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: [hidden email]
>>> For additional commands, e-mail: [hidden email]
>>>
>>


---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

Re: [lang]

Phil Steitz
In reply to this post by Duncan Jones


> On May 6, 2014, at 10:51 PM, Duncan Jones <[hidden email]> wrote:
>
>> On 7 May 2014 01:52, "Paul Benedict" <[hidden email]> wrote:
>>
>> When you dereference a null pointer, you get an NPE. We can agree to that.
>> We can also agree it's not inherently wrong to throw IAE on a null
> argument
>> check, but this discussion has never been about that. The discussion has
>> always centered on what the trend setters are doing -- and they say go
> with
>> NPE.
>>
>> Oracle/Sun throws NPE in its method:
> http://docs.oracle.com/javase/7/docs/api/java/util/Objects.html#requireNonNull%28T%29
>>
>> Google Guava throws NPE in its method:
> http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/base/Preconditions.html#checkNotNull%28T%29
>>
>> It's pretty clear where industry is going and not using NPE is not
>> expected. We shouldn't try to resist where all the thought leaders in our
>> industry are going. It doesn't make any sense. No matter what personal
>> affinity/preference you have towards IAE, it's a losing battle because the
>> march is going the other direction.
>
> This is a very compelling point. We don't want to alienate our user base
> because a handful of us believe the Java community is going in the wrong
> direction.
>
> I could be swayed by that argument alone. We hardly need more reasons for
> people to consider Lang to be outdated compared with Guava etc.

Interesting how I see that argument as exactly the opposite - ie if the only "argument" in support of a technical decision is "that's where things are going" I see that as a good reason not to capitulate.  The best thing about OSS (at least how we have traditionally done it here @apache) is we make technical decisions based on technical arguments and the people who actually contribute to the code get listened to.  So instead of vague references to "thought leaders" or what others are doing, what matters is what arguments are presented here.  In this thread, I have yet to see a good argument for tossing npe when an API advertises parm checking.  Do you have one?  Does anyone else?

Phil

>
>>
>> Paul
>>
>>
>> Cheers,
>> Paul
>>
>>
>>> On Tue, May 6, 2014 at 6:27 PM, sebb <[hidden email]> wrote:
>>>
>>>> On 6 May 2014 22:54, Paul Benedict <[hidden email]> wrote:
>>>> This is not a matter of law. If Oracle/Sun set a direction on how to
> use
>>>> NPE, it's a really good idea to follow them -- even if you don't
> agree,
>>> do
>>>> it for the sake of consistency. I don't think using IAE is somehow
>>> "better"
>>>> Java than what they are doing. And I give weight to what Joshua said
>>>> because he's a former architect of that company. Lang3 was designed to
>>>> throw NPE on invalid null arguments because that's what the gurus,
> like
>>> he,
>>>> in our industry who publish "best practices" say it should. If your
>>> opinion
>>>> bears greater weight than those set forth the best practices, then you
>>> win,
>>>> but I don't advocate going back to IAE for nulls for the reasons
> stated.
>>>
>>> The problem is still that NPE can be thrown by the JVM for code bugs.
>>> If you Google/Bing for "what does NPE mean?" most of the postings say
>>> that this is due to a bug in the code that throws it rather than a bug
>>> in the code that calls it.
>>>
>>> There is nothing inherently wrong with using IAE for reporting a null
>>> argument.
>>> I think it was a mistake to suggest using NPE for that.
>>> One might as well throw ArithmeticException for a zero argument that
>>> is going to be used as a divisor.
>>> Neither is as helpful as IAE.
>>>
>>> The problem is that NPE is ambiguous. IAE is not.
>>>
>>>>
>>>>
>>>>
>>>> Cheers,
>>>> Paul
>>>>
>>>>
>>>>> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]>
>>>> wrote:
>>>>
>>>>>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>>>>
>>>>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>>>>
>>>>>>> Hi Thiago,
>>>>>>>
>>>>>>>
>>>>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>>>>
>>>>>>>> Hello people,
>>>>>>>>
>>>>>>>> Analizing the JIRA issue
>>>>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>>>>> contributors noticed that NumberUtils.max/min methods all have
> the
>>> same
>>>>>>>> problem:
>>>>>>>> They all throw an IllegalArgumentException when according to the
>>>>> official
>>>>>>>> documentation (Oracle|Sun) says that a NullPointerException must
> be
>>>>> thrown
>>>>>>>> when an argument must not be null.
>>>>>>>
>>>>>>> This is not a problem imho. It is a question of API design. I
> don't
>>> now
>>>>> an
>>>>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>>>>> Sun/Oracle
>>>>>>> at some point decided to throw NPE when ever a null reference is
>>> passed
>>>>> to
>>>>>>> a method that doesn't accept null inputs. I don't feel this is
> right,
>>>>> since
>>>>>>> a null input is also an illegal argument. Why make a
> differenciation?
>>>>> IMHO
>>>>>>> NPE should be reserved to the JVM, when a method is called on a
> null
>>>>>>> reference, but that's just my opinion.
>>>>>>
>>>>>>
>>>>>> It *is* a problem because NullPointerException and
>>>>> IllegalArgumentException have concrete semantics layed out in the
> JDK's
>>>>> Javadocs. If you see how both are used in the JDK, you see that NPE
> and
>>> IAE
>>>>> are used properly and there is no such restriction to the JDK only.
> If
>>> you
>>>>> aread Effective Java, you'll see that you *have to* use NPE if a null
>>>>> argument is passed. One might remember the NullArgumentException
> back in
>>>>> Lang 2, it was removed because it is imperative to use NPE instead.
>>>>>
>>>>> Effective Java is a great book, but don't confuse Joshua's advice
> with
>>> law.
>>>>>
>>>>>>
>>>>>> Moreover, the Lang 3 package includes a great class, Validate,
> which
>>> does
>>>>> things right and now I can ask, why the hell is that not used
> throughout
>>>>> the entire library?
>>>>>
>>>>> +1 to this. We should update all of lang to use Validate once we've
>>> nailed
>>>>> this issue.
>>>>>
>>>>> Duncan
>>>>>
>>>>>>
>>>>>>
>>>>>>>> However according to Apache Commons Lang Developer Guide, these
>>> methods
>>>>> are
>>>>>>>> all correct. This guide says that "When throwing an exception to
>>>>> indicate a
>>>>>>>> bad argument, always try to throw IllegalArgumentException, even
> if
>>> the
>>>>>>>> argument was null. Do not throw NullPointerException.".
>>>>>>
>>>>>>
>>>>>> Correct to the dev guide only -- not Java.
>>>>>>
>>>>>>
>>>>>>> Since [lang] is currently designed this way, I'd rather deal with
>>> this
>>>>>>> issue for 4.0. We can then revisit our initial decision to only
> throw
>>>>> IAE
>>>>>>> an maybe align it to what the JDK now does. If you want to file an
>>>>> issue,
>>>>>>> my opinion is, that it should be fix version 4.0. Changing the
>>>>> exceptions
>>>>>>> that are thrown now may break clients (although I think there are
>>> very
>>>>> few
>>>>>>> use cases where one should catch IAE or NPE).
>>>>>>
>>>>>>
>>>>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>>>>> indicate a programming error in the client not adhering to the
> contract
>>>>> depicted by the Javadocs, so it is the client's problem to deal with
>>> them.
>>>>> With proper programming, you should not have to catch those
> exception at
>>>>> all.
>>>>>>
>>>>>>
>>>>>>>> This mail was sent in order to discuss around and make decisions
> to
>>>>> solve
>>>>>>>> this dilemma where the Java official specification says X and the
>>>>> Apache
>>>>>>>> official specification says Y.
>>>>>>>
>>>>>>> Can you please provide a lnk to the official specification you're
>>>>> refering
>>>>>>> to? ;-)
>>>>>>
>>>>>>
>>>>>> Read Effective Java on exceptions. Thiago provided a URL in the
> JIRA
>>>>> issue.
>>>>>>
>>>>>> Further good resources:
>>>>>>
>>>>>> 1.
> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html
>>>>>> 2.
>>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html
> :
>>>>> "One case where it is common practice to throw a RuntimeException is
>>> when
>>>>> the user calls a method incorrectly. For example, a method can check
> if
>>> one
>>>>> of its arguments is incorrectly null. If an argument is null, the
> method
>>>>> might throw a NullPointerException, which is an unchecked exception."
>>>>>>
>>>>>> Michael
> ---------------------------------------------------------------------
>>>>>> To unsubscribe, e-mail: [hidden email]
>>>>>> For additional commands, e-mail: [hidden email]
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: [hidden email]
>>> For additional commands, e-mail: [hidden email]
>>>
>>>

---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

Re: [lang]

garydgregory
In reply to this post by Ralph Goers
On Thu, May 8, 2014 at 12:24 AM, Ralph Goers <[hidden email]>wrote:

> I have to say that if you look at the JDK for examples of how to code Java
> correctly you will be disappointed.  There are lots and lots of classes
> that are really bad.
>

Sadly, you need experience to pick and choose what guidelines to follow
from the JDK's own source.

I'm amazed at the lack of changes and evolution in some classes.

Some code looks like it was last edited in a 40 char wide stone tablet :)

Gary


> Ralph
>
>
> On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:
>
> > This is not a matter of law. If Oracle/Sun set a direction on how to use
> > NPE, it's a really good idea to follow them -- even if you don't agree,
> do
> > it for the sake of consistency. I don't think using IAE is somehow
> "better"
> > Java than what they are doing. And I give weight to what Joshua said
> > because he's a former architect of that company. Lang3 was designed to
> > throw NPE on invalid null arguments because that's what the gurus, like
> he,
> > in our industry who publish "best practices" say it should. If your
> opinion
> > bears greater weight than those set forth the best practices, then you
> win,
> > but I don't advocate going back to IAE for nulls for the reasons stated.
> >
> >
> >
> >
> > Cheers,
> > Paul
> >
> >
> > On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]>
> wrote:
> >
> >> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
> >>>
> >>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
> >>>
> >>>> Hi Thiago,
> >>>>
> >>>>
> >>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
> >>>>
> >>>>> Hello people,
> >>>>>
> >>>>> Analizing the JIRA issue
> >> https://issues.apache.org/jira/browse/LANG-1008the
> >>>>> contributors noticed that NumberUtils.max/min methods all have the
> same
> >>>>> problem:
> >>>>> They all throw an IllegalArgumentException when according to the
> >> official
> >>>>> documentation (Oracle|Sun) says that a NullPointerException must be
> >> thrown
> >>>>> when an argument must not be null.
> >>>>>
> >>>>
> >>>> This is not a problem imho. It is a question of API design. I don't
> now
> >> an
> >>>> offical documentation that say when IAE or NPE _must_ be thrown.
> >> Sun/Oracle
> >>>> at some point decided to throw NPE when ever a null reference is
> passed
> >> to
> >>>> a method that doesn't accept null inputs. I don't feel this is right,
> >> since
> >>>> a null input is also an illegal argument. Why make a differenciation?
> >> IMHO
> >>>> NPE should be reserved to the JVM, when a method is called on a null
> >>>> reference, but that's just my opinion.
> >>>
> >>>
> >>> It *is* a problem because NullPointerException and
> >> IllegalArgumentException have concrete semantics layed out in the JDK's
> >> Javadocs. If you see how both are used in the JDK, you see that NPE and
> IAE
> >> are used properly and there is no such restriction to the JDK only. If
> you
> >> aread Effective Java, you'll see that you *have to* use NPE if a null
> >> argument is passed. One might remember the NullArgumentException back in
> >> Lang 2, it was removed because it is imperative to use NPE instead.
> >>
> >> Effective Java is a great book, but don't confuse Joshua's advice with
> law.
> >>
> >>>
> >>> Moreover, the Lang 3 package includes a great class, Validate, which
> does
> >> things right and now I can ask, why the hell is that not used throughout
> >> the entire library?
> >>
> >> +1 to this. We should update all of lang to use Validate once we've
> nailed
> >> this issue.
> >>
> >> Duncan
> >>
> >>>
> >>>
> >>>>> However according to Apache Commons Lang Developer Guide, these
> methods
> >> are
> >>>>> all correct. This guide says that "When throwing an exception to
> >> indicate a
> >>>>> bad argument, always try to throw IllegalArgumentException, even if
> the
> >>>>> argument was null. Do not throw NullPointerException.".
> >>>
> >>>
> >>> Correct to the dev guide only -- not Java.
> >>>
> >>>
> >>>> Since [lang] is currently designed this way, I'd rather deal with this
> >>>> issue for 4.0. We can then revisit our initial decision to only throw
> >> IAE
> >>>> an maybe align it to what the JDK now does. If you want to file an
> >> issue,
> >>>> my opinion is, that it should be fix version 4.0. Changing the
> >> exceptions
> >>>> that are thrown now may break clients (although I think there are very
> >> few
> >>>> use cases where one should catch IAE or NPE).
> >>>
> >>>
> >>> 4.0 has to use Validate throughout the entire package. NPE and IAE
> >> indicate a programming error in the client not adhering to the contract
> >> depicted by the Javadocs, so it is the client's problem to deal with
> them.
> >> With proper programming, you should not have to catch those exception at
> >> all.
> >>>
> >>>
> >>>>> This mail was sent in order to discuss around and make decisions to
> >> solve
> >>>>> this dilemma where the Java official specification says X and the
> >> Apache
> >>>>> official specification says Y.
> >>>>>
> >>>>
> >>>> Can you please provide a lnk to the official specification you're
> >> refering
> >>>> to? ;-)
> >>>
> >>>
> >>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
> >> issue.
> >>>
> >>> Further good resources:
> >>>
> >>> 1.
> >>
> >>
> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html
> >>> 2.
> >>
> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html:
> >> "One case where it is common practice to throw a RuntimeException is
> when
> >> the user calls a method incorrectly. For example, a method can check if
> one
> >> of its arguments is incorrectly null. If an argument is null, the method
> >> might throw a NullPointerException, which is an unchecked exception."
> >>>
> >>> Michael
> >>>
> >>>
> >>>
> >>> ---------------------------------------------------------------------
> >>> To unsubscribe, e-mail: [hidden email]
> >>> For additional commands, e-mail: [hidden email]
> >>>
> >>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>
>


--
E-Mail: [hidden email] | [hidden email]
Java Persistence with Hibernate, Second Edition<http://www.manning.com/bauer3/>
JUnit in Action, Second Edition <http://www.manning.com/tahchiev/>
Spring Batch in Action <http://www.manning.com/templier/>
Blog: http://garygregory.wordpress.com
Home: http://garygregory.com/
Tweet! http://twitter.com/GaryGregory
Reply | Threaded
Open this post in threaded view
|

RE: [lang]

Roger Whitcomb
In reply to this post by Ralph Goers
Just wanted to mention that the Apache Pivot project (Java GUI framework) uses IAE for most/all cases of null or invalid input arguments (that is, cases where we check the input arguments), reserving NPE for basically the JVM to throw.

~Roger Whitcomb

-----Original Message-----
From: Ralph Goers [mailto:[hidden email]]
Sent: Wednesday, May 07, 2014 9:25 PM
To: Commons Developers List
Subject: Re: [lang]

I have to say that if you look at the JDK for examples of how to code Java correctly you will be disappointed.  There are lots and lots of classes that are really bad.

Ralph


On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:

> This is not a matter of law. If Oracle/Sun set a direction on how to
> use NPE, it's a really good idea to follow them -- even if you don't
> agree, do it for the sake of consistency. I don't think using IAE is somehow "better"
> Java than what they are doing. And I give weight to what Joshua said
> because he's a former architect of that company. Lang3 was designed to
> throw NPE on invalid null arguments because that's what the gurus,
> like he, in our industry who publish "best practices" say it should.
> If your opinion bears greater weight than those set forth the best
> practices, then you win, but I don't advocate going back to IAE for nulls for the reasons stated.
>
>
>
>
> Cheers,
> Paul
>
>
> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]> wrote:
>
>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>
>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>
>>>> Hi Thiago,
>>>>
>>>>
>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>
>>>>> Hello people,
>>>>>
>>>>> Analizing the JIRA issue
>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>> contributors noticed that NumberUtils.max/min methods all have the
>>>>> same
>>>>> problem:
>>>>> They all throw an IllegalArgumentException when according to the
>> official
>>>>> documentation (Oracle|Sun) says that a NullPointerException must
>>>>> be
>> thrown
>>>>> when an argument must not be null.
>>>>>
>>>>
>>>> This is not a problem imho. It is a question of API design. I don't
>>>> now
>> an
>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>> Sun/Oracle
>>>> at some point decided to throw NPE when ever a null reference is
>>>> passed
>> to
>>>> a method that doesn't accept null inputs. I don't feel this is
>>>> right,
>> since
>>>> a null input is also an illegal argument. Why make a differenciation?
>> IMHO
>>>> NPE should be reserved to the JVM, when a method is called on a
>>>> null reference, but that's just my opinion.
>>>
>>>
>>> It *is* a problem because NullPointerException and
>> IllegalArgumentException have concrete semantics layed out in the
>> JDK's Javadocs. If you see how both are used in the JDK, you see that
>> NPE and IAE are used properly and there is no such restriction to the
>> JDK only. If you aread Effective Java, you'll see that you *have to*
>> use NPE if a null argument is passed. One might remember the
>> NullArgumentException back in Lang 2, it was removed because it is imperative to use NPE instead.
>>
>> Effective Java is a great book, but don't confuse Joshua's advice with law.
>>
>>>
>>> Moreover, the Lang 3 package includes a great class, Validate, which
>>> does
>> things right and now I can ask, why the hell is that not used
>> throughout the entire library?
>>
>> +1 to this. We should update all of lang to use Validate once we've
>> +nailed
>> this issue.
>>
>> Duncan
>>
>>>
>>>
>>>>> However according to Apache Commons Lang Developer Guide, these
>>>>> methods
>> are
>>>>> all correct. This guide says that "When throwing an exception to
>> indicate a
>>>>> bad argument, always try to throw IllegalArgumentException, even
>>>>> if the argument was null. Do not throw NullPointerException.".
>>>
>>>
>>> Correct to the dev guide only -- not Java.
>>>
>>>
>>>> Since [lang] is currently designed this way, I'd rather deal with
>>>> this issue for 4.0. We can then revisit our initial decision to
>>>> only throw
>> IAE
>>>> an maybe align it to what the JDK now does. If you want to file an
>> issue,
>>>> my opinion is, that it should be fix version 4.0. Changing the
>> exceptions
>>>> that are thrown now may break clients (although I think there are
>>>> very
>> few
>>>> use cases where one should catch IAE or NPE).
>>>
>>>
>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>> indicate a programming error in the client not adhering to the
>> contract depicted by the Javadocs, so it is the client's problem to deal with them.
>> With proper programming, you should not have to catch those exception
>> at all.
>>>
>>>
>>>>> This mail was sent in order to discuss around and make decisions
>>>>> to
>> solve
>>>>> this dilemma where the Java official specification says X and the
>> Apache
>>>>> official specification says Y.
>>>>>
>>>>
>>>> Can you please provide a lnk to the official specification you're
>> refering
>>>> to? ;-)
>>>
>>>
>>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
>> issue.
>>>
>>> Further good resources:
>>>
>>> 1.
>>
>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerExcepti
>> on.html
>>> 2.
>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html:
>> "One case where it is common practice to throw a RuntimeException is
>> when the user calls a method incorrectly. For example, a method can
>> check if one of its arguments is incorrectly null. If an argument is
>> null, the method might throw a NullPointerException, which is an unchecked exception."
>>>
>>> Michael
>>>
>>>
>>>
>>> --------------------------------------------------------------------
>>> - To unsubscribe, e-mail: [hidden email]
>>> For additional commands, e-mail: [hidden email]
>>>
>>


---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]




---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

RE: [lang]

Kish, Robert
What I haven't seen anyone mention yet is my point of view as a user. I
don't mind getting back NPE - I just want an error message in the
exception when that happens. If I get back null as the text, then that
usually tells me the error is a JVM one or an unexpected one in the
library I'm using. When I get back an exception message or an IAE, then
I know it's something I did.

What I don't want to see happen is throwing NPE with no text, in place
of IAE. That's the case where a user of the library might be confused as
to the cause of the exception.

-----Original Message-----
From: Roger Whitcomb [mailto:[hidden email]]
Sent: Tuesday, May 13, 2014 02:16 PM
To: Commons Developers List
Subject: RE: [lang]

Just wanted to mention that the Apache Pivot project (Java GUI
framework) uses IAE for most/all cases of null or invalid input
arguments (that is, cases where we check the input arguments), reserving
NPE for basically the JVM to throw.

~Roger Whitcomb

-----Original Message-----
From: Ralph Goers [mailto:[hidden email]]
Sent: Wednesday, May 07, 2014 9:25 PM
To: Commons Developers List
Subject: Re: [lang]

I have to say that if you look at the JDK for examples of how to code
Java correctly you will be disappointed.  There are lots and lots of
classes that are really bad.

Ralph


On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:

> This is not a matter of law. If Oracle/Sun set a direction on how to
> use NPE, it's a really good idea to follow them -- even if you don't
> agree, do it for the sake of consistency. I don't think using IAE is
somehow "better"
> Java than what they are doing. And I give weight to what Joshua said
> because he's a former architect of that company. Lang3 was designed to

> throw NPE on invalid null arguments because that's what the gurus,
> like he, in our industry who publish "best practices" say it should.
> If your opinion bears greater weight than those set forth the best
> practices, then you win, but I don't advocate going back to IAE for
nulls for the reasons stated.
>
>
>
>
> Cheers,
> Paul
>
>
> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]>
wrote:

>
>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>
>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>
>>>> Hi Thiago,
>>>>
>>>>
>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>
>>>>> Hello people,
>>>>>
>>>>> Analizing the JIRA issue
>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>> contributors noticed that NumberUtils.max/min methods all have the

>>>>> same
>>>>> problem:
>>>>> They all throw an IllegalArgumentException when according to the
>> official
>>>>> documentation (Oracle|Sun) says that a NullPointerException must
>>>>> be
>> thrown
>>>>> when an argument must not be null.
>>>>>
>>>>
>>>> This is not a problem imho. It is a question of API design. I don't

>>>> now
>> an
>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>> Sun/Oracle
>>>> at some point decided to throw NPE when ever a null reference is
>>>> passed
>> to
>>>> a method that doesn't accept null inputs. I don't feel this is
>>>> right,
>> since
>>>> a null input is also an illegal argument. Why make a
differenciation?
>> IMHO
>>>> NPE should be reserved to the JVM, when a method is called on a
>>>> null reference, but that's just my opinion.
>>>
>>>
>>> It *is* a problem because NullPointerException and
>> IllegalArgumentException have concrete semantics layed out in the
>> JDK's Javadocs. If you see how both are used in the JDK, you see that

>> NPE and IAE are used properly and there is no such restriction to the

>> JDK only. If you aread Effective Java, you'll see that you *have to*
>> use NPE if a null argument is passed. One might remember the
>> NullArgumentException back in Lang 2, it was removed because it is
imperative to use NPE instead.
>>
>> Effective Java is a great book, but don't confuse Joshua's advice
with law.
>>
>>>
>>> Moreover, the Lang 3 package includes a great class, Validate, which

>>> does
>> things right and now I can ask, why the hell is that not used
>> throughout the entire library?
>>
>> +1 to this. We should update all of lang to use Validate once we've
>> +nailed
>> this issue.
>>
>> Duncan
>>
>>>
>>>
>>>>> However according to Apache Commons Lang Developer Guide, these
>>>>> methods
>> are
>>>>> all correct. This guide says that "When throwing an exception to
>> indicate a
>>>>> bad argument, always try to throw IllegalArgumentException, even
>>>>> if the argument was null. Do not throw NullPointerException.".
>>>
>>>
>>> Correct to the dev guide only -- not Java.
>>>
>>>
>>>> Since [lang] is currently designed this way, I'd rather deal with
>>>> this issue for 4.0. We can then revisit our initial decision to
>>>> only throw
>> IAE
>>>> an maybe align it to what the JDK now does. If you want to file an
>> issue,
>>>> my opinion is, that it should be fix version 4.0. Changing the
>> exceptions
>>>> that are thrown now may break clients (although I think there are
>>>> very
>> few
>>>> use cases where one should catch IAE or NPE).
>>>
>>>
>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>> indicate a programming error in the client not adhering to the
>> contract depicted by the Javadocs, so it is the client's problem to
deal with them.
>> With proper programming, you should not have to catch those exception

>> at all.
>>>
>>>
>>>>> This mail was sent in order to discuss around and make decisions
>>>>> to
>> solve
>>>>> this dilemma where the Java official specification says X and the
>> Apache
>>>>> official specification says Y.
>>>>>
>>>>
>>>> Can you please provide a lnk to the official specification you're
>> refering
>>>> to? ;-)
>>>
>>>
>>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
>> issue.
>>>
>>> Further good resources:
>>>
>>> 1.
>>
>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerExcepti
>> on.html
>>> 2.
>>
http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html
:
>> "One case where it is common practice to throw a RuntimeException is
>> when the user calls a method incorrectly. For example, a method can
>> check if one of its arguments is incorrectly null. If an argument is
>> null, the method might throw a NullPointerException, which is an
unchecked exception."

>>>
>>> Michael
>>>
>>>
>>>
>>> --------------------------------------------------------------------
>>> - To unsubscribe, e-mail: [hidden email]
>>> For additional commands, e-mail: [hidden email]
>>>
>>


---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]




---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]


---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

Re: [lang]

Oliver Heger-3
In reply to this post by Roger Whitcomb
I remembered this discussion just today at work when I was faced with
the following situation: a method is passed parameters which must not be
null and must otherwise be compliant to some validity rules.

So what would authorities recommend: Throw NPE in case of a null
argument and IAE in case of other contract violations? This seems
confusing to me. Therefore, I am in favor of IAE.

Oliver

Am 13.05.2014 20:15, schrieb Roger Whitcomb:

> Just wanted to mention that the Apache Pivot project (Java GUI framework) uses IAE for most/all cases of null or invalid input arguments (that is, cases where we check the input arguments), reserving NPE for basically the JVM to throw.
>
> ~Roger Whitcomb
>
> -----Original Message-----
> From: Ralph Goers [mailto:[hidden email]]
> Sent: Wednesday, May 07, 2014 9:25 PM
> To: Commons Developers List
> Subject: Re: [lang]
>
> I have to say that if you look at the JDK for examples of how to code Java correctly you will be disappointed.  There are lots and lots of classes that are really bad.
>
> Ralph
>
>
> On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:
>
>> This is not a matter of law. If Oracle/Sun set a direction on how to
>> use NPE, it's a really good idea to follow them -- even if you don't
>> agree, do it for the sake of consistency. I don't think using IAE is somehow "better"
>> Java than what they are doing. And I give weight to what Joshua said
>> because he's a former architect of that company. Lang3 was designed to
>> throw NPE on invalid null arguments because that's what the gurus,
>> like he, in our industry who publish "best practices" say it should.
>> If your opinion bears greater weight than those set forth the best
>> practices, then you win, but I don't advocate going back to IAE for nulls for the reasons stated.
>>
>>
>>
>>
>> Cheers,
>> Paul
>>
>>
>> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]> wrote:
>>
>>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>>
>>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>>
>>>>> Hi Thiago,
>>>>>
>>>>>
>>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>>
>>>>>> Hello people,
>>>>>>
>>>>>> Analizing the JIRA issue
>>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>>> contributors noticed that NumberUtils.max/min methods all have the
>>>>>> same
>>>>>> problem:
>>>>>> They all throw an IllegalArgumentException when according to the
>>> official
>>>>>> documentation (Oracle|Sun) says that a NullPointerException must
>>>>>> be
>>> thrown
>>>>>> when an argument must not be null.
>>>>>>
>>>>>
>>>>> This is not a problem imho. It is a question of API design. I don't
>>>>> now
>>> an
>>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>>> Sun/Oracle
>>>>> at some point decided to throw NPE when ever a null reference is
>>>>> passed
>>> to
>>>>> a method that doesn't accept null inputs. I don't feel this is
>>>>> right,
>>> since
>>>>> a null input is also an illegal argument. Why make a differenciation?
>>> IMHO
>>>>> NPE should be reserved to the JVM, when a method is called on a
>>>>> null reference, but that's just my opinion.
>>>>
>>>>
>>>> It *is* a problem because NullPointerException and
>>> IllegalArgumentException have concrete semantics layed out in the
>>> JDK's Javadocs. If you see how both are used in the JDK, you see that
>>> NPE and IAE are used properly and there is no such restriction to the
>>> JDK only. If you aread Effective Java, you'll see that you *have to*
>>> use NPE if a null argument is passed. One might remember the
>>> NullArgumentException back in Lang 2, it was removed because it is imperative to use NPE instead.
>>>
>>> Effective Java is a great book, but don't confuse Joshua's advice with law.
>>>
>>>>
>>>> Moreover, the Lang 3 package includes a great class, Validate, which
>>>> does
>>> things right and now I can ask, why the hell is that not used
>>> throughout the entire library?
>>>
>>> +1 to this. We should update all of lang to use Validate once we've
>>> +nailed
>>> this issue.
>>>
>>> Duncan
>>>
>>>>
>>>>
>>>>>> However according to Apache Commons Lang Developer Guide, these
>>>>>> methods
>>> are
>>>>>> all correct. This guide says that "When throwing an exception to
>>> indicate a
>>>>>> bad argument, always try to throw IllegalArgumentException, even
>>>>>> if the argument was null. Do not throw NullPointerException.".
>>>>
>>>>
>>>> Correct to the dev guide only -- not Java.
>>>>
>>>>
>>>>> Since [lang] is currently designed this way, I'd rather deal with
>>>>> this issue for 4.0. We can then revisit our initial decision to
>>>>> only throw
>>> IAE
>>>>> an maybe align it to what the JDK now does. If you want to file an
>>> issue,
>>>>> my opinion is, that it should be fix version 4.0. Changing the
>>> exceptions
>>>>> that are thrown now may break clients (although I think there are
>>>>> very
>>> few
>>>>> use cases where one should catch IAE or NPE).
>>>>
>>>>
>>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>>> indicate a programming error in the client not adhering to the
>>> contract depicted by the Javadocs, so it is the client's problem to deal with them.
>>> With proper programming, you should not have to catch those exception
>>> at all.
>>>>
>>>>
>>>>>> This mail was sent in order to discuss around and make decisions
>>>>>> to
>>> solve
>>>>>> this dilemma where the Java official specification says X and the
>>> Apache
>>>>>> official specification says Y.
>>>>>>
>>>>>
>>>>> Can you please provide a lnk to the official specification you're
>>> refering
>>>>> to? ;-)
>>>>
>>>>
>>>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
>>> issue.
>>>>
>>>> Further good resources:
>>>>
>>>> 1.
>>>
>>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerExcepti
>>> on.html
>>>> 2.
>>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html:
>>> "One case where it is common practice to throw a RuntimeException is
>>> when the user calls a method incorrectly. For example, a method can
>>> check if one of its arguments is incorrectly null. If an argument is
>>> null, the method might throw a NullPointerException, which is an unchecked exception."
>>>>
>>>> Michael
>>>>
>>>>
>>>>
>>>> --------------------------------------------------------------------
>>>> - To unsubscribe, e-mail: [hidden email]
>>>> For additional commands, e-mail: [hidden email]
>>>>
>>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>

---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

Re: [lang]

Duncan Jones
In reply to this post by Phil Steitz
On 13 May 2014 02:02, Phil Steitz <[hidden email]> wrote:

>
>
>> On May 6, 2014, at 10:51 PM, Duncan Jones <[hidden email]> wrote:
>>
>>> On 7 May 2014 01:52, "Paul Benedict" <[hidden email]> wrote:
>>>
>>> When you dereference a null pointer, you get an NPE. We can agree to that.
>>> We can also agree it's not inherently wrong to throw IAE on a null
>> argument
>>> check, but this discussion has never been about that. The discussion has
>>> always centered on what the trend setters are doing -- and they say go
>> with
>>> NPE.
>>>
>>> Oracle/Sun throws NPE in its method:
>> http://docs.oracle.com/javase/7/docs/api/java/util/Objects.html#requireNonNull%28T%29
>>>
>>> Google Guava throws NPE in its method:
>> http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/base/Preconditions.html#checkNotNull%28T%29
>>>
>>> It's pretty clear where industry is going and not using NPE is not
>>> expected. We shouldn't try to resist where all the thought leaders in our
>>> industry are going. It doesn't make any sense. No matter what personal
>>> affinity/preference you have towards IAE, it's a losing battle because the
>>> march is going the other direction.
>>
>> This is a very compelling point. We don't want to alienate our user base
>> because a handful of us believe the Java community is going in the wrong
>> direction.
>>
>> I could be swayed by that argument alone. We hardly need more reasons for
>> people to consider Lang to be outdated compared with Guava etc.
>
> Interesting how I see that argument as exactly the opposite - ie if the only "argument" in support of a technical decision is "that's where things are going" I see that as a good reason not to capitulate.  The best thing about OSS (at least how we have traditionally done it here @apache) is we make technical decisions based on technical arguments and the people who actually contribute to the code get listened to.  So instead of vague references to "thought leaders" or what others are doing, what matters is what arguments are presented here.  In this thread, I have yet to see a good argument for tossing npe when an API advertises parm checking.  Do you have one?  Does anyone else?

I have no technical arguments to present - IAE is the only sensible
technical option. I quite like your opinion that we should pave the
way with what we think is correct behaviour. I'm firmly back in the
IAE camp, I think.

On a similar subject, I note that the Validate.validIndex() methods
throw IndexOutOfBoundsException. I see this as the same argument as
NPE - we should throw IAE instead, since IOOBE is similarly a
"something went wrong" exception, rather than a validation exception.

Duncan



>
> Phil
>>
>>>
>>> Paul
>>>
>>>
>>> Cheers,
>>> Paul
>>>
>>>
>>>> On Tue, May 6, 2014 at 6:27 PM, sebb <[hidden email]> wrote:
>>>>
>>>>> On 6 May 2014 22:54, Paul Benedict <[hidden email]> wrote:
>>>>> This is not a matter of law. If Oracle/Sun set a direction on how to
>> use
>>>>> NPE, it's a really good idea to follow them -- even if you don't
>> agree,
>>>> do
>>>>> it for the sake of consistency. I don't think using IAE is somehow
>>>> "better"
>>>>> Java than what they are doing. And I give weight to what Joshua said
>>>>> because he's a former architect of that company. Lang3 was designed to
>>>>> throw NPE on invalid null arguments because that's what the gurus,
>> like
>>>> he,
>>>>> in our industry who publish "best practices" say it should. If your
>>>> opinion
>>>>> bears greater weight than those set forth the best practices, then you
>>>> win,
>>>>> but I don't advocate going back to IAE for nulls for the reasons
>> stated.
>>>>
>>>> The problem is still that NPE can be thrown by the JVM for code bugs.
>>>> If you Google/Bing for "what does NPE mean?" most of the postings say
>>>> that this is due to a bug in the code that throws it rather than a bug
>>>> in the code that calls it.
>>>>
>>>> There is nothing inherently wrong with using IAE for reporting a null
>>>> argument.
>>>> I think it was a mistake to suggest using NPE for that.
>>>> One might as well throw ArithmeticException for a zero argument that
>>>> is going to be used as a divisor.
>>>> Neither is as helpful as IAE.
>>>>
>>>> The problem is that NPE is ambiguous. IAE is not.
>>>>
>>>>>
>>>>>
>>>>>
>>>>> Cheers,
>>>>> Paul
>>>>>
>>>>>
>>>>>> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]>
>>>>> wrote:
>>>>>
>>>>>>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>>>>>
>>>>>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>>>>>
>>>>>>>> Hi Thiago,
>>>>>>>>
>>>>>>>>
>>>>>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>>>>>
>>>>>>>>> Hello people,
>>>>>>>>>
>>>>>>>>> Analizing the JIRA issue
>>>>>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>>>>>> contributors noticed that NumberUtils.max/min methods all have
>> the
>>>> same
>>>>>>>>> problem:
>>>>>>>>> They all throw an IllegalArgumentException when according to the
>>>>>> official
>>>>>>>>> documentation (Oracle|Sun) says that a NullPointerException must
>> be
>>>>>> thrown
>>>>>>>>> when an argument must not be null.
>>>>>>>>
>>>>>>>> This is not a problem imho. It is a question of API design. I
>> don't
>>>> now
>>>>>> an
>>>>>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>>>>>> Sun/Oracle
>>>>>>>> at some point decided to throw NPE when ever a null reference is
>>>> passed
>>>>>> to
>>>>>>>> a method that doesn't accept null inputs. I don't feel this is
>> right,
>>>>>> since
>>>>>>>> a null input is also an illegal argument. Why make a
>> differenciation?
>>>>>> IMHO
>>>>>>>> NPE should be reserved to the JVM, when a method is called on a
>> null
>>>>>>>> reference, but that's just my opinion.
>>>>>>>
>>>>>>>
>>>>>>> It *is* a problem because NullPointerException and
>>>>>> IllegalArgumentException have concrete semantics layed out in the
>> JDK's
>>>>>> Javadocs. If you see how both are used in the JDK, you see that NPE
>> and
>>>> IAE
>>>>>> are used properly and there is no such restriction to the JDK only.
>> If
>>>> you
>>>>>> aread Effective Java, you'll see that you *have to* use NPE if a null
>>>>>> argument is passed. One might remember the NullArgumentException
>> back in
>>>>>> Lang 2, it was removed because it is imperative to use NPE instead.
>>>>>>
>>>>>> Effective Java is a great book, but don't confuse Joshua's advice
>> with
>>>> law.
>>>>>>
>>>>>>>
>>>>>>> Moreover, the Lang 3 package includes a great class, Validate,
>> which
>>>> does
>>>>>> things right and now I can ask, why the hell is that not used
>> throughout
>>>>>> the entire library?
>>>>>>
>>>>>> +1 to this. We should update all of lang to use Validate once we've
>>>> nailed
>>>>>> this issue.
>>>>>>
>>>>>> Duncan
>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>> However according to Apache Commons Lang Developer Guide, these
>>>> methods
>>>>>> are
>>>>>>>>> all correct. This guide says that "When throwing an exception to
>>>>>> indicate a
>>>>>>>>> bad argument, always try to throw IllegalArgumentException, even
>> if
>>>> the
>>>>>>>>> argument was null. Do not throw NullPointerException.".
>>>>>>>
>>>>>>>
>>>>>>> Correct to the dev guide only -- not Java.
>>>>>>>
>>>>>>>
>>>>>>>> Since [lang] is currently designed this way, I'd rather deal with
>>>> this
>>>>>>>> issue for 4.0. We can then revisit our initial decision to only
>> throw
>>>>>> IAE
>>>>>>>> an maybe align it to what the JDK now does. If you want to file an
>>>>>> issue,
>>>>>>>> my opinion is, that it should be fix version 4.0. Changing the
>>>>>> exceptions
>>>>>>>> that are thrown now may break clients (although I think there are
>>>> very
>>>>>> few
>>>>>>>> use cases where one should catch IAE or NPE).
>>>>>>>
>>>>>>>
>>>>>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>>>>>> indicate a programming error in the client not adhering to the
>> contract
>>>>>> depicted by the Javadocs, so it is the client's problem to deal with
>>>> them.
>>>>>> With proper programming, you should not have to catch those
>> exception at
>>>>>> all.
>>>>>>>
>>>>>>>
>>>>>>>>> This mail was sent in order to discuss around and make decisions
>> to
>>>>>> solve
>>>>>>>>> this dilemma where the Java official specification says X and the
>>>>>> Apache
>>>>>>>>> official specification says Y.
>>>>>>>>
>>>>>>>> Can you please provide a lnk to the official specification you're
>>>>>> refering
>>>>>>>> to? ;-)
>>>>>>>
>>>>>>>
>>>>>>> Read Effective Java on exceptions. Thiago provided a URL in the
>> JIRA
>>>>>> issue.
>>>>>>>
>>>>>>> Further good resources:
>>>>>>>
>>>>>>> 1.
>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html
>>>>>>> 2.
>>>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html
>> :
>>>>>> "One case where it is common practice to throw a RuntimeException is
>>>> when
>>>>>> the user calls a method incorrectly. For example, a method can check
>> if
>>>> one
>>>>>> of its arguments is incorrectly null. If an argument is null, the
>> method
>>>>>> might throw a NullPointerException, which is an unchecked exception."
>>>>>>>
>>>>>>> Michael
>> ---------------------------------------------------------------------
>>>>>>> To unsubscribe, e-mail: [hidden email]
>>>>>>> For additional commands, e-mail: [hidden email]
>>>>
>>>> ---------------------------------------------------------------------
>>>> To unsubscribe, e-mail: [hidden email]
>>>> For additional commands, e-mail: [hidden email]
>>>>
>>>>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>

---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

Reply | Threaded
Open this post in threaded view
|

Re: [lang]

garydgregory
In reply to this post by Thiago Andrade
+1

Gary

<div>-------- Original message --------</div><div>From: Oliver Heger <[hidden email]> </div><div>Date:05/13/2014  15:33  (GMT-05:00) </div><div>To: Commons Developers List <[hidden email]> </div><div>Subject: Re: [lang] </div><div>
</div>I remembered this discussion just today at work when I was faced with
the following situation: a method is passed parameters which must not be
null and must otherwise be compliant to some validity rules.

So what would authorities recommend: Throw NPE in case of a null
argument and IAE in case of other contract violations? This seems
confusing to me. Therefore, I am in favor of IAE.

Oliver

Am 13.05.2014 20:15, schrieb Roger Whitcomb:

> Just wanted to mention that the Apache Pivot project (Java GUI framework) uses IAE for most/all cases of null or invalid input arguments (that is, cases where we check the input arguments), reserving NPE for basically the JVM to throw.
>
> ~Roger Whitcomb
>
> -----Original Message-----
> From: Ralph Goers [mailto:[hidden email]]
> Sent: Wednesday, May 07, 2014 9:25 PM
> To: Commons Developers List
> Subject: Re: [lang]
>
> I have to say that if you look at the JDK for examples of how to code Java correctly you will be disappointed.  There are lots and lots of classes that are really bad.
>
> Ralph
>
>
> On May 6, 2014, at 2:54 PM, Paul Benedict <[hidden email]> wrote:
>
>> This is not a matter of law. If Oracle/Sun set a direction on how to
>> use NPE, it's a really good idea to follow them -- even if you don't
>> agree, do it for the sake of consistency. I don't think using IAE is somehow "better"
>> Java than what they are doing. And I give weight to what Joshua said
>> because he's a former architect of that company. Lang3 was designed to
>> throw NPE on invalid null arguments because that's what the gurus,
>> like he, in our industry who publish "best practices" say it should.
>> If your opinion bears greater weight than those set forth the best
>> practices, then you win, but I don't advocate going back to IAE for nulls for the reasons stated.
>>
>>
>>
>>
>> Cheers,
>> Paul
>>
>>
>> On Tue, May 6, 2014 at 4:40 PM, Duncan Jones <[hidden email]> wrote:
>>
>>> On 6 May 2014 22:27, "Michael Osipov" <[hidden email]> wrote:
>>>>
>>>> Am 2014-05-06 15:27, schrieb Benedikt Ritter:
>>>>
>>>>> Hi Thiago,
>>>>>
>>>>>
>>>>> 2014-05-06 14:53 GMT+02:00 Thiago Andrade <[hidden email]>:
>>>>>
>>>>>> Hello people,
>>>>>>
>>>>>> Analizing the JIRA issue
>>> https://issues.apache.org/jira/browse/LANG-1008the
>>>>>> contributors noticed that NumberUtils.max/min methods all have the
>>>>>> same
>>>>>> problem:
>>>>>> They all throw an IllegalArgumentException when according to the
>>> official
>>>>>> documentation (Oracle|Sun) says that a NullPointerException must
>>>>>> be
>>> thrown
>>>>>> when an argument must not be null.
>>>>>>
>>>>>
>>>>> This is not a problem imho. It is a question of API design. I don't
>>>>> now
>>> an
>>>>> offical documentation that say when IAE or NPE _must_ be thrown.
>>> Sun/Oracle
>>>>> at some point decided to throw NPE when ever a null reference is
>>>>> passed
>>> to
>>>>> a method that doesn't accept null inputs. I don't feel this is
>>>>> right,
>>> since
>>>>> a null input is also an illegal argument. Why make a differenciation?
>>> IMHO
>>>>> NPE should be reserved to the JVM, when a method is called on a
>>>>> null reference, but that's just my opinion.
>>>>
>>>>
>>>> It *is* a problem because NullPointerException and
>>> IllegalArgumentException have concrete semantics layed out in the
>>> JDK's Javadocs. If you see how both are used in the JDK, you see that
>>> NPE and IAE are used properly and there is no such restriction to the
>>> JDK only. If you aread Effective Java, you'll see that you *have to*
>>> use NPE if a null argument is passed. One might remember the
>>> NullArgumentException back in Lang 2, it was removed because it is imperative to use NPE instead.
>>>
>>> Effective Java is a great book, but don't confuse Joshua's advice with law.
>>>
>>>>
>>>> Moreover, the Lang 3 package includes a great class, Validate, which
>>>> does
>>> things right and now I can ask, why the hell is that not used
>>> throughout the entire library?
>>>
>>> +1 to this. We should update all of lang to use Validate once we've
>>> +nailed
>>> this issue.
>>>
>>> Duncan
>>>
>>>>
>>>>
>>>>>> However according to Apache Commons Lang Developer Guide, these
>>>>>> methods
>>> are
>>>>>> all correct. This guide says that "When throwing an exception to
>>> indicate a
>>>>>> bad argument, always try to throw IllegalArgumentException, even
>>>>>> if the argument was null. Do not throw NullPointerException.".
>>>>
>>>>
>>>> Correct to the dev guide only -- not Java.
>>>>
>>>>
>>>>> Since [lang] is currently designed this way, I'd rather deal with
>>>>> this issue for 4.0. We can then revisit our initial decision to
>>>>> only throw
>>> IAE
>>>>> an maybe align it to what the JDK now does. If you want to file an
>>> issue,
>>>>> my opinion is, that it should be fix version 4.0. Changing the
>>> exceptions
>>>>> that are thrown now may break clients (although I think there are
>>>>> very
>>> few
>>>>> use cases where one should catch IAE or NPE).
>>>>
>>>>
>>>> 4.0 has to use Validate throughout the entire package. NPE and IAE
>>> indicate a programming error in the client not adhering to the
>>> contract depicted by the Javadocs, so it is the client's problem to deal with them.
>>> With proper programming, you should not have to catch those exception
>>> at all.
>>>>
>>>>
>>>>>> This mail was sent in order to discuss around and make decisions
>>>>>> to
>>> solve
>>>>>> this dilemma where the Java official specification says X and the
>>> Apache
>>>>>> official specification says Y.
>>>>>>
>>>>>
>>>>> Can you please provide a lnk to the official specification you're
>>> refering
>>>>> to? ;-)
>>>>
>>>>
>>>> Read Effective Java on exceptions. Thiago provided a URL in the JIRA
>>> issue.
>>>>
>>>> Further good resources:
>>>>
>>>> 1.
>>>
>>> http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerExcepti
>>> on.html
>>>> 2.
>>> http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html:
>>> "One case where it is common practice to throw a RuntimeException is
>>> when the user calls a method incorrectly. For example, a method can
>>> check if one of its arguments is incorrectly null. If an argument is
>>> null, the method might throw a NullPointerException, which is an unchecked exception."
>>>>
>>>> Michael
>>>>
>>>>
>>>>
>>>> --------------------------------------------------------------------
>>>> - To unsubscribe, e-mail: [hidden email]
>>>> For additional commands, e-mail: [hidden email]
>>>>
>>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [hidden email]
> For additional commands, e-mail: [hidden email]
>

---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]

12