Stephen Colebourne

Noteworthy, the oracle JDK license has apparently changed so you can't legally use their distribution for much of anything except for the development of inhouse java applications? So I guess you can't even use it just for its JRE to run, say, eclipse for PHP development, or to host a servlet web server? Anyways looks like the OpenJDK is now on feature parity and is GPL licensed. https://blog.joda.org/2018/08/java-is-still-available-at-zero-cost.htm…

It does not seem to be uncommon to recommend staying away from the non-LTS releases. It is probably not only up to you whether or not your software supports the next JDK release; all your tooling and libraries need to do so as well. See http://blog.joda.org/2018/02/java-9-has-six-weeks-to-live.html for more insight.

"If you're using Java 8, you can use the excellent new Optional type. If a value may or may not be present, wrap it in an Optional class like this" While I agree with most things, overuse of Optional like this is an antipattern IMO. Having done a lot of Java 8 development, I find Optional is best for return types, but otherwise forcing callers to wrap values in Optional is unnecessary as opposed to something like Scala. Those that work on the JDK feel the same [1][2] and I think [2] is even overuse with the prevalence of static analysis tools and @Nullable. Although a tad dated, I find [3] to be a good guide to modern Java all around. 1 - http://stackoverflow.com/questions/26327957/should-java-8-getters-retu… 2 - http://blog.joda.org/2015/08/java-se-8-optional-pragmatic-approach.htm… 3 - http://blog.paralleluniverse.co/2014/05/01/modern-java/

For more information on the vote of Java 7: http://blog.joda.org/2011/06/java-se-7-passes-in-zombie-jcp_1590.html And an excellent summary of how the FOU came to be (with pictures): http://blog.joda.org/2009/03/sun-apache-ip-in-pictures_9067.html

"Constantly making waves" is probably more accurate from the days back when Tony Morris was active on the mailing lists. Paul, I believe, also made a fair bit of waves back in the day, but for some reason his were always much more palatable. (He has a very good writing style and is never, that I really remember, flat out mean.) I guess the big waves I remember are essentially about a post a week from Tony. The hoopla around Colebourne's opinions on the language[1]. And then the mystery/whatever around Pollak's involvement in the community.[2] The later point is odd just for how much traction lift seemed to be generating, and then the overall community appeared to reject it heavily. Do note that I would still recommend it. Their community is quite nice and helpful. And I should definitely make clear that it is very possible I just don't see the waves in other communities. I don't really see Scala's anymore; this week being a notable exception. To me, though, high tension is not exactly a good environment. Heck, for all of the flack he gets, Torvalds is usually more cordial than many of the threads I remember from this community. [1] http://blog.joda.org/2011/11/scala-feels-like-ejb-2-and-other.html [2] http://blog.goodstuff.im/yes-virginia-scala-is-hard

Java has been around for a longish time. Around the early 2000's there was at least a perception that you should avoid creating too many objects as that carried performance overhead for construction and garbage collection. https://softwareengineering.stackexchange.com/questions/149563/should-… Immutable objects often require you to construct a new object to store an updated value and garbage collect the now unused previous object. So a lot of early Java code was written with mutable objects to avoid performance issues. The Java Bean spec was written in 1997: https://blog.joda.org/2014/11/the-javabeans-specification.html

I wrote up an alternative proposal here: https://blog.joda.org/2022/10/fully-defined-entrypoints.html My concept is much more powerful by having a new kind of class declaration alongside 'record' and 'enum' - 'entrypoint'.

https://blog.joda.org/2011/08/common-java-method-names.html?m=1 has some background into the logic of static factory naming, covering from() and of().

Java is definitely not free. https://blog.joda.org/2018/09/do-not-fall-into-oracles-java-11-trap.ht…

The author of Joda-Time actually thinks that even Joda-Time didn't get it quite right, and believes the java.time libraries in Java 8 and above (aka JSR-310[1]) are better than Joda-Time: https://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html It turns out that abstractions for time are really hard to get right. [1] https://jcp.org/en/jsr/detail?id=310

Related https://blog.joda.org/2018/09/do-not-fall-into-oracles-java-11-trap.ht… (on HN https://news.ycombinator.com/item?id=18074727)

I believe you're mistaken. The article is saying that there are two versions of Java, and one has the license that you mentioned while the other is free and open source. From that article: https://blog.joda.org/2018/09/do-not-fall-into-oracles-java-11-trap.ht… > As well as their commercial JDK, Oracle produce an OpenJDK build. It is $free, zero-cost and GPL licensed (with Classpath exception so safe for commercial use). Download $free Java here: https://jdk.java.net/11/ jdk.java.net/11 in turn says: > This page provides production-ready open-source builds of the Java Development Kit, version 11, an implementation of the Java SE 11 Platform under the GNU General Public License, version 2, with the Classpath Exception.

The latest versions of Java will continue to be free. All you need to do to "pay" for that is remain up to date. Only maintenance on older versions of Java will be subscription based. Only free for non-production use. This was on HN yesterday: https://blog.joda.org/2018/09/do-not-fall-into-oracles-java-11-trap.ht…

It's pretty straight forward to migrate from Joda to Java 8's builtin classes though. Just remove the dependency on Joda Time and let the compiler tell you which files to fix. This blog post lists which Java 8 classes replace their Joda Time counterparts: https://blog.joda.org/2014/11/converting-from-joda-time-to-javatime.ht…

Here is the rebuttal which shows that this is patently false for all actual use cases: http://blog.joda.org/2018/08/java-is-still-available-at-zero-cost.html

No, Stephen Colebourne has recently written a blog post [1] on that subject. [1] http://blog.joda.org/2018/08/java-is-still-available-at-zero-cost.html

"Java 9 is obsolete [...]. What? You haven't upgraded yet? Well, Java 10 is only going to last six months before it is obsolete too." http://blog.joda.org/2018/02/java-9-has-six-weeks-to-live.html

Lots of noise here about what it actually consists of. This blog post is a good overview[1] > Creating a module is relatively simple however. A module is typically just a jar file that has a module-info.class file at the root - known as a modular jar file. And that file is created from a module-info.java file in your sourcebase (see below for more details). > Using a modular jar file involves adding the jar file to the modulepath instead of the classpath. If a modular jar file is on the classpath, it will not act as a module at all, and the module-info.class will be ignored. As such, while a modular jar file on the modulepath will have hidden packages enforced by the JVM, a modular jar file on the classpath will not have hidden packages at all. [1] http://blog.joda.org/2017/04/java-9-modules-jpms-basics.html

Java 10 is supposed to introduce value types, that will change the way we use nulls, check here: http://blog.joda.org/2014/11/better-nulls-in-java-10.html

>Joda-Time doesn't copy 100% java.util.date but I don't know what the threshold is. I think they're safe, especially given that the process has actually come full circle now. The new date time package in Java 8 (java.time) was developed under JSR310, whose spec lead is none other than the developer of Joda-Time, Stephen Colebourne [1] For those that are interested, he wrote an interesting blog post way back in 2009 on why they chose to develop JSR-310 instead of using Joda as is [2], as well a more recent piece on the bits that didn't make the cut (and are thus now part of a separate project) [3]. [1] https://jcp.org/en/jsr/detail?id=310 [2] http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html [3] http://blog.joda.org/2014/02/new-project-threeten-extra-for-jdk-8.html

Whereas i'd say it should definitely be based on Stephen Colebourne's ThreeTen, which is the successor to Joda-Time: http://www.threeten.org/ http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html The language constructs might not be as close to Rust's, but the semantics benefit from years of additional experience and thought.

Because one of the main authors behind JSR-310 happens to be the JodaTime author and considers it to be inspired by JodaTime, even if it's different to fix some flawed assumptions JodaTime made [1]. And as far as practical use goes, they're very similar, since they draw upon the same concepts. I don't see how it isn't a fair description, especially when you compare to how bad Date/Calendar are right now. [1] http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html

- Type erasure - true but it results in a very small increase in overall verbosity. - Null - true but Scala's approach is perhaps more verbose than Java's. I like Groovy's approach the most (). - Functional if - definitely disagree that it makes tons of code simpler / easier to read. - Java 8 has traits (but I'm not sure if they're equivalent to Scala's traits). - Nonfunctional core API's – Guava helps here. – Reference-reseating-by-default - don't know what you mean by that. I don't think Scala is the next Java. Personally, I wish Kotlin, Ceylon or Dart would replace Java. Scala makes the wrong expressivness / simplicity tradeoff. > outside of the epistemic closure of the Java world it is rapidly becoming understood that Java is better at nothing by design Not true. Yammer moved back from Scala to Java: http://blog.joda.org/2011/11/real-life-scala-feedback-from-yammer.html

I doubt there's too much of a learning curve as the new API is pretty similar to Joda Time: http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html

http://blog.joda.org/search?q=jsr-310 provides some interesting backstory to the JSR-310 / Joda Time saga...

> Do you have a link? http://blog.joda.org/2011/11/scala-ejb-2-feedback.html?showComment=132… I don't question the intent of the Scala community. There's no mystic group of evildoers there trying to degrade newcomers. But the mailing list is very intimidating. It doesn't feel like a place where newbies can come in and ask "How do I do a 'foreach' loop?".

Nobody said Yammer said publicly announces that scala doesn't suit them. Actually, someone did. The original post that `leaked` this email says something to that effect http://blog.joda.org/2011/11/real-life-scala-feedback-from-yammer.html

Chris Marshall has a notable response in the comments: http://blog.joda.org/2011/11/scala-feels-like-ejb-2-and-other.html?sho…

This saga goes back to Sun Microsystems and Apache Harmony. Harmony, as originally announced was to be an Apache 2.0 License cleanroom reimplementation of the Java platform, complete with the standard library and a VM [1]. There was a lot of confusion [2] going forward, because copyleft folks like GNU were working on Classpath, a similar project, under the GPLv2, and none of that code was license-compatible with the Apache License. This was one of the high-profile catalysts of the harmonization of open-source licenses that happened later, contributing to the future GPLv3. Harmony ran into plenty of other challenges, but despite the odds it managed to produce a working J2SE 5 implementation. It was speculated that Sun was theoretically okay with a copyleft open source Java, but not one that wasn't copyleft, like Harmony. Specifically, they laid out conditions in the license for the Java Compatibility Kit, the conformance test suite needing to be passed to claim that you're "Java", that disallowed certain "Field[s] of Use" i.e. natures of deployment [3][4]. The "Field of Use" restrictions that Sun has imposed restrict software certified with the TCK to "general computing devices" which would for instance restrict use on kiosks or mobile devices. [5] The Field of Use restrictions limiting J2SE 5 implementations to "General Purpose Computing Devices" and excluding special-case appliances, kiosks, mobile computing devices and other interesting applications constitutes an…

This is a talk by Brian Goetz about the design of Java 8's lambdas: http://parleys.com/play/5251c164e4b0a43ac1212459/about A lot of thought has been put into that, and I think the result is both elegant and at the same time integrates beautifully with legacy code. Perhaps most importantly, a lot of existing libraries will automatically support lambdas naturally without them ever being designed for lambdas and without recompilation. Java's lambdas have been anything but rushed. They were debated long and hard (for literally years), and different approaches were considered, tried and discarded before the present spec was accepted. Here's a summary of the discussion from 2007: http://blog.joda.org/2007/12/closures-comparing-core-of-bgga-cice_9112… In the end, the "BGGA" proposal for full function types in Java was rejected in favor of something similar to the Doug Lea-Josh Bloch-Bob Lee proposal. Bob Lee summarized his perspective so[1]: "Loosely speaking, simple syntax sugar for anonymous inner classes buys Java 90% of the power of BGGA closures while carrying only 10% of the weight. We think it's the "knee in curve" where we get the most bang for our buck." This is perfectly in line with the Java philosophy. Other languages may prefer getting 100% of the power for ten times the cost, which might make sense if your requirements and use cases are different. In the end, though, Lambda's are more powerful than the original "concise syntax for anonymous classes" because…