Nat Pryce

A few that I follow on a semi-regular basis: https://michaelfeathers.silvrback.com http://highscalability.com http://techblog.netflix.com http://www.natpryce.com https://8thlight.com/blog/ https://www.percona.com/blog/ https://www.smashingmagazine.com http://blog.crisp.se/author/henrikkniberg https://m.signalvnoise.com https://dannorth.net/blog/ https://codeascraft.com

Too bad that 1.0 will ship without something like Scala Future's. Now you can only have a similar functionality with CompletableStage. It would've been way better to actually have a similar implementation than scala.Future. I mean they wouldn't need Quasar, Akka for basic stuff. However currently you need to stick to Java pendants. Kotlin has some great things, but overall I still prefer Scala over Kotlin for anything not Android related. I mean what I would've loved in 1.0: - specify Bytecode Level output 6, 7, 8, (9) - Futures - Macros (Big one especially for SQL Libraries really helpful) - Buildsystem supported by Jetbrains. - Support for all major Java Build Systems directly by Jetbrains However at the moment, kotlin feels like "here we developed a language which we will use internally and we will do the stuff we need, for everything else, do what you please", while most languages do this, the newer ones actually coming with more stuff, ie. rust has a package manager, a build system (it only lacks libraries, where kotlin wouldn't suffer, thanks to java), golang which has also something like a package manager and a build system and a rich library which has great support for "threading". i mean on kotlin you could use maven or gradle. however maven is like: <dosomething></dosomething> ugliness. and gradle is okai, but it feels wierd sometimes especially since code highlighting in intellij always feels broken. currently I'm way more looking…

A license like this has two red flags. I previously worked in a programme providing corporate governance of open source. It's a fairly big industry with companies like Black Duck helping companies manage their legal risks, and licenses like this aren't popular. Firstly, it's non-standard. As others have said, it's the author's right to make it non-standard, but I don't recommend people try that unless there's a really good reason to do so. If it's non-standard, a lot of companies simply won't use it. There's no box to check, so you can't have it. Good tracking software will of course allow for exceptions and deltas to the standard contracts, but it still creates delays and management overheads as if it's allowed at all, it will require someone's manual sign-off. This gets worse when you consider the whole chain of software use. One library inside another library that's used by a subcontractor who added it to a build script that's used by the main contractor to distribute to developers. The whole thing needs to be linked through, which is hard enough with standard licenses. Now startups don't need to worry about sign-off from some department, but they still need to stop and inspect the nature of the licenses they're using, and a non-standard license causes extra time and energy lost. The second problem is ambiguity. A non-standard contract can still be precisely written, so developers know what they're getting into. In this case, though, it's not. It hinges around the…

Ideally we want something like class Stream<T> { <R, X> Stream<R> map( Function<? super T, ? extends R, throws X> mapper ) throws X } and if you pass a function that throws, say, IOException and SQLException, then X=IOException|SQLException and that's what that call to #map throws. You can sort of do it by http://natpryce.com/articles/000738.html but you have to choose one base type and you can't make stdlib support it.

"Dependency Injection" Considered Harmful: http://www.natpryce.com/articles/000783.html