skysight-inc/HackerNews huggingface dataset:
As is true most other languages, tbh. Java isn't the hardest one either, with Eclipse/IntelliJ/Maven/blahblah, it takes time to configure, but fairly established.
No, he uses commit messages as log of his thoughts, and commits need to have changes, thus each "log only" commit deletes or adds those same whitespaces in a never ending cycle.

In between you find some actual code changes (with also long commit messages).

It's not that he's finished - I hardly guess so because he complains that he'd need 10 years of time to polish everything out perfectly (in his opinion) and he only has one - it's just his style for a log book...
I can see how comparing server-side Java to Flash would be an unpopular opinion (since it doesn't make any sense at all).
>Back then bytes and string were the same thing.

No, they weren't. Impossible as it seems, we had encodings (including multi-byte encodings) for decades before UTF.

Python couldn't use UTF-8 in 1991, but it could very well tag strings with a specific encoding, instead of treating them as a bucket of bytes C-style.

>Java did do it right but by 1995 the industry had already seen the problems of differing character sets.

We had seen the problems of "differing character sets" for decades already (Windows vs DOS version of the same language encodings was a classic example for most users, but the problems go back to EBCDIC and so on).

Java just did a more right thing, but we already have a need for generic string types that can handle multiple encodings and know what they contain and how to convert from one to another.
Mailgun API, SMTP and control panel are down
Informally speaking, that can be visualised by asking "how many half pieces can you get if you have x pieces?" If I have two pieces I can break them down into 4 half pieces, which nets the same result as multiplying by two.
You can use this:
(https://www.amazon.com/Akitio-Node-Thunderbolt3-Windows-Comp...)

It costs $250 + GPU.
Author says Java was relatively new in 2007 although introduced in 1995... I’m not sure what is meant.

Java is many things: the language? The vm? The ecosystem?

I keep hearing that Java is fast, and indeed hotspot is but every system I encounter that’s written in Java is sluggish.

I keep hearing that Java lost its abstractwidgetfactoryfactoryfactory fetish, and I think it’s improved in the last 15 years, but it’s still horrible.

My view:The language is meh; acceptable syntax, reasonable performance. The ecosystem is bleh - only if you really love bureaucracy.
Historically, Gradle is a Java build system, isn't it?
Node.js is 9 years old and is also very stable with a large ecosystem. It's far from "hype train" in 2018 and it's more the mature technology - though it's still moving fast forward with new tools and paradigms it's very stable.
While CloudFormation is lovely, it has a couple of real downsides:

- very often something new is introduced on AWS without any CloudFormation support, so you will either need to write custom resources with lambda functions, or be prepared to wait a long time. From the few times I checked TF is actually faster to support new services / features.

- CloudFormation has extensive documentation, but very often you end up having to also read AWS API documentation and going through a dozen trial & error attempts before you get something working.

- occasionally CloudFormation can get stuck and leave you in a state you can not recover from. Luckily AWS support tends to be very responsive and can help you here, and it hasn't been happening as much as 1-2 years ago

- CloudFormation has very little support for reusing things: no macro support, very limited include support, no support for YAML aliases (unless you use "aws cloudformation package" as a workaround)

- CloudFormation changesets are nice, but do not work if you use sub-stacks (which you should use)

Just like Zope there is a bit of a Z-shaped learning curve: there is a pretty steep learning curve to start, after which a lot of things become easy. But when you get to more complex things suddenly everything becomes frustratingly difficult again. That may come with the territory; I have not used other tools such as TF so I can't tell if that is a problem-space specific thing.
so basically multiplayer MS paint? heck, it's a good idea!
I think its the other way, there are only a few languages with as superb IDE support as Java. AFAIK its just C++, Java and C#.

You can get shitty support with just syntax coloring for anything and anywhere of course.
I have to assume you're trolling me at this point, but just in case not:

https://amturing.acm.org/award_winners/milner_1569367.cfm

https://en.wikipedia.org/wiki/Robin_Milner

ML did not spring fully-formed from the heads of the creators of OCaml…
I'm not sure it is social media, rather I think it's the price. Free or very cheap opens you up to a group of people you wouldn't normally have to deal with.
This is great stuff. Thank you.
China breaks up underground $1.5B World Cup crypto-gambling ring
> That is still an extremely small minority who would upgrade.

It's really not, and it's quite obvious that the baseless assertion that no one wants to upgrade hardware is rather mind-numbingly absurd.

There are businesses dedicated to repair, upgrade and refurbish computers, including laptops. There are businesses dedicated to sell used hardware which offer clients a choice of processors and other components, including different makes and models. It's utterly absurd that we're supposed that this basic need simply vanishes in a specific form factor.
I wrote this in 2014 and think it's still reasonably relevant: https://mcconnellsoftware.github.io/java-golden-handcuffs/
No and no but that's my dream.
Living in the foundations, missing all the amenities
It's implicit - but my criticism here is mostly that once you know one development stack learning others is significantly easier.

Learning Java is something that a backend developer can likely do in a week - and so is learning Node.js after knowing Java.
What version of DrRacket are you in?
That's just one of the neighborhoods though. But Barcelona's grid neighborhood Eixample it's a very interesting design: https://en.wikipedia.org/wiki/Eixample
Well, yes and no.

Sure, it would be best if you learn all of them, but that's just impossible and not terribly useful.

What "Should I learn X" is implicitly "Given limited lifespan, will learning X, pay off for me".

Both in the literal sense like a well payed job and in the sense of making you a better programmer, which kinda depends on your previous experiences (e.g. learning Lisp dialect is kinda worthless, if you already know another Lisp dialect, learning C# pays less if you already know Java and F#).
Sometimes I feel like there's not much left people haven't figured out, and then I see something like this: pentagons that can tile a surface aren't fully worked out mathematically. You'd think that would be something we'd have covered, but no — there's wonder left in the world!
Just like cognitive science has a much higher replication rate than social psychology, you will get different results with different subfields.
American Cities Are Drowning in Car Storage
In the area that I live there are plenty of eatable mushrooms but sadly none like that. I wonder how it actually tastes but wouldn't ever pay so much for a mushroom
I was at the tail end of the Java-first code teaching approach - the Stanford open courseware I was following in 2013 was largely built on top of Java. Stanford switched those courses to Javascript a couple of years later.

Java has definite advantages over its scripting cousins when it comes to learning the OOP paradigm, program patterns/anti-patterns and typing. You can't really get away with not knowing any of it in Java (as opposed to Python), but the language is still fairly newbie-friendly (as opposed to C++). Additionally, Java 8 is a fairly decent introduction to functional programming for people who've never worked with it before.

All that said, right now I wouldn't start a new codebase in Java unless I really, really had to. Learn your fundamentals through Java, then get comfortable in something else and code your projects in that instead.
That is the trade off. It’s not exactly a revelation given the definition of RAID 5.
Nice! I think it may be slightly out of date though. For example, you don't need Tuples library if you use Apache commons because it has Tuple support. Also, Javaslang has been renamed Vavr. Still a solid article though
APPLE'S MACBOOK PROS GET FASTER CHIPS, NEW KEYBOARDS (KINDA)
Source: https://www.wired.com/story/macbook-pro-with-touch-bar-2018

MACBOOK PROS ARE becoming worthy of their “Pro” moniker again. Apple just refreshed its line of professional laptops, a move that had been recently rumored. The new MacBook Pros, which go on sale today, get a bump in processor speeds, RAM, and internal storage. They also allow you summon Siri at all times by using just your voice.

The announcement shows how Apple is leaning heavily into its marketing around creative professionals, just as its education announcement a few months ago leaned heavily into the creative aspects of education devices. And that makes a lot of sense for Apple. At the same time, though, these updates aren’t addressing all of the issues that users have had with recent generations of MacBook Pro, nor do the updates apply to the entirety of the Mac laptop line.

For example, the new MacBook Pros also have new keyboards. But the keyboards haven’t been completely redesigned, which is notable considering the reams of grief caused by the previous design. This also means there could potentially still be issues with Apple’s ultra-thin, butterfly-switch keyboards, even on the new machines.

For more news visit: www.industry-era.com and go to news section
Interesting article - I've just partially resurrected a "Pro" Stylophone (Model 350s) for a client of mine - it was horribly corroded internally (battery leakage), and also in need of a decent PSU (as the default 18v supply from two 9v batteries on this model drastically reduces the lifespan of some of the components) running at about 15v.

Unfortunately the keyboard and resistor ladder were too badly corroded to make it economically viable to fix it (client didn't want to pay - it would have taken me at least half a day to do it properly, and it's not really worth that when you can get a recon one for £199), so only half the keyboard works well (or as well as a stylophone ever did). The 350s added some interesting extras to the original stylophone - different waveforms (described with names of real instruments which is stretching it a bit), a 'reiteration' stylus (which produced a rhythmic on/off of the note selected with it), and an optical sensor for Wah-Wah or vibrato intensity. I'd imagine that properly built it would have been an interesting machine, although I don't know where it sat price-wise against 'real' synthesizers of the day. The owner has had a few hit songs, and it was interesting to realise that it was the actual instrument I was repairing that featured on one of his hits!

Pity that the whole thing is somewhat tainted with the association with Rolf Harris, like so many things from my youth in the 70s in the UK.
You’ll pay a lot but you’ll get more than you paid for
Before I started work on Spiral I spent way too long, like a year working on a ML library before throwing in the towel. I think I skimmed through the source of DeepML over a year ago and my impression was that the author was struggling against the limitations of F#'s type system. There were a bunch of places where he was doing the equivalent of telling the compiler to fuck itself by downcasting to `System.Object`.

The way these projects go is that you start of with an AD library and then when the type system and the language starts getting in the way you either do a lot, and I mean a LOT of engineering with inferior tools or you make something better.

The 'make something better' is always picked and can take various forms. Generally, people would not make a decision to work on a language for a ML library for almost a year before they write down the first line for it. They instead take the middle road of starting with an AD library and gradually extending it.

First they realize that they cannot really express tensors properly with the confines of the language so they make everything symbolic, then they build engines to run such symbolic AST, then they realize that they need JITs and other optimizers to make everything run fast. Tensorflow and PyTorch are currently at this stage. There are more stages after this.

Of course the task of working with ASTs is what a compiler does. I think it is a great pity that Tensorflow and PyTorch are written in C++ under the hood. C++ is probably the worst language I can imagine for working on compilers, so I applaud the authors of DeepML for picking F# instead. Had the TF team picked statically typed functional language for this they could have cut the size of TF by over 10x and saved themselves over a million lines of code.

[ML](https://en.wikipedia.org/wiki/Standard_ML) derivatives like it were made for that sort of thing and I cannot imagine doing Spiral in a non-ML styled language.
Hmm. Just checked memory use on some services we run on Go, Node, and Java. I'm not part of the Java team but results:

Go: 40M
Node: 64M
Java: 4GB

Any Java service I've seen in production has similar numbers. Coupled with the incredible startup time it's hard for me to see why you'd pick it in 2018.
Accountability to Scale an Organization
People who ask this question are implicitly asking:

"Given the difficulty/time requirements of learning something and the salary/technology trends of our industry, does it make sense to invest in the mastery of abstraction X?"

The time I have outside of my sprint is really limited, so getting expert guidance on whether knowing Rust will benefit me more than knowing Java is in fact extremely valuable to me.
> but its actually 5-10x slower than Java and uses 5-10X more memory

I am definitely against the "Java is slow" claims and think they are mostly rediculous but so is this claim.

Saying "uses 5-10x more memory and 5-10x slower" goes against every benchmark I've ever run and my understanding.

Mostly because JavaScript runs on several JITs (V8, JavaScriptCore, SpiderMonkey, Chakra) with different performance goals and characteristics and so does Java (which runs very differently with Art compared to HotSpot for example). Not to mention things like Graal :)

Slowness isn't a property of the language it's a property of the runtime. Usually performance is dominated by things like the speed of the packages used and standard library and not even the compiler.

There is no 5-10x factor _either way_ between JavaScript and Java VMs, not to mention you can run JavaScript on the Java VM anyway so that comparison doesn't hold in that regard either.
Easiest way of visualising the pythagorean theorem is to think about it the way it was initially written: think about areas formed by tree squares.

This image[0] from wikipedia shows it all: the area of square a plus the area of square b equals the area of square c. It's just really convenient that we can use that to calculate triangle sides without resorting to trigonometry.

[0] https://upload.wikimedia.org/wikipedia/commons/thumb/d/d2/Py...
As much as I like Clojure (and Clojurescript) whenever I want to actually get things done, I have to switch back to the simple Java jax.rs based backend and either native Android, or ReactJS based web front end.

I am kinda sick of spending days fighting with half-backed tools that would eventually give me a better and more productive workflow, just to get to the "almost there with only a few missing things" and finally giving up.

That being said, I have a high hopes for Flutter for the front end mobile development. From what I have seen from quick playing with it, it's as friction-less as it can get.
Kotlin can be as ugly as Scala.
>The best papers get up to around .20. Again, No Paper Is That Good. If you demur, consider this: In twenty years, will you still hold up the best papers of today as “paragons” or “exemplars” of compelling empirical work?

If the field is not totally vague, then yes. We can still consider certain papers in physics, or chemistry, or medicine, computer science etc. as exemplary decades, or even centuries, later, even when they deal with empirical work.

Soft sciences need not apply.
yeah, also in 2019 and 2020. it's only getting better and better. the echosystem is amazing. I think you should focus on 3 languages:

1. Java for stable heavy big projects with lot of develpers.
2. Typescript for frontend lifting.
3. Python for machine learning and data analysis.

Master those 3 and general programming and system design concepts this is what i'm working on.
Before going multi module and needing special control on the build process and having a LOT of code, what exactly hellish do you think someone and a beginner at that will encounter? I have been writing it professionally for 5 years and I find it ok.
"bus lurking around the corner" caused me a Family Guy style flashback.

"Like that time [victim of an unsolved bus stop stabbing] was killed by a bus." victim sitting alone at a bus stop. glint of light from the dark alley in back. bus jumps out, stabs victim. bus enters street, transforms into normal bus, drives off.
I think that its time that the enterprise switches to full stack Typescript as a much better solution for developing enterprise software.

Why use two languages and two different ecosystems for the backend and for the frontend, when we can use only one? It makes hiring a lot easier too.

Let's face it the Java ecosystem is stagnated and has lost a tremendous amount of mindshare in the last 7 years.

The level of modularity that they are trying to achieve has been available in Node since 2009, while all the language features that they are trying to implement are already there in a Typescript in a much better form.

The Java ecosystem did not manage to produce a good frontend development solution, and that was its downfall.

Things like JSF and later GWT did not deliver on the promise of abstracting away the browser for non-frontend developers, and the result is that you have to be both a frontend developer (HTML/CSS/Javascript ) and a Java developer in order to build UIs in Java.
IMO the enhancements of Java over the last few versions have been very well chosen. I can't think of another language which has improved so much, and with so little hassle to developers.

streams, type inference, lambda expressions, an official REPL: big changes, which effectively targeted some of the biggest pain-points in earlier Java.
To me it is. You read the paper and then make up your mind on it. You do not dismiss a whole bunch of literature on the basis of two papers someone has provided to you.

There is nothing wrong with choosing your literature carefully, but that's far from the original suggestion. You can and should use your bullshit detector.
Learning another language is _significantly_ easier than learning the first one or two

Learning the syntax, sure. But to be productive at a commercial level in any language these days is about knowing your way around the ecosystem, libraries, tooling etc, and that takes a significant investment of time, and the knowledge is highly perishable.

3-4 languages is probably the most it’s reasonable to maintain and to claim as an actual skill.
> someone had their caplocks setup to be esc on click, or control on hold

I have this setup, and it is great. After you switch capslock to be Ctrl, just run (at startup):

xcape -e 'Control_L=Escape'
There's not a lot of information given here. The blog post is better [1].

Long story short, they decided to augment Wire with experimental post-quantum security using the NewHope key exchange scheme.

You can read more about NewHope here [2]. It's a lattice-based cryptosystem using the Ring-Learning With Errors (R-LWE) problem. It's also the same post-quantum key exchange scheme Google experimented with in Google Chrome [3]. R-LWE is pretty common in state of the art lattice-based cryptosystems (there are several such, including NewHope, in Round 1 of the NIST PQCrypto CFP [4]).

Among the mathematical "tribes" of post-quantum cryptography, lattice-based (and code-based) problems are particularly good for speed. On the other hand, their key sizes are significantly larger (this phenomenon is somewhat inverted in supersingular isogenies, which offer fantastic key sizes but much slower key exchange). For those interested in learning more about the learning with errors problem (and its ring-augmented cousin), the first few pages of the NewHope specification (and most lattice-based specs from NIST PQCrypto) are a good brief [5]. And while it's not related to NewHope specifically, Peikert's survey on lattice-based cryptography is relatively recent and accessible [6].

I'm interested in what impact this will have on latency in Wire. In the context of the Google Chrome TLS experiment, the median connection latency increased by 1ms, the slowest 5% increased by 20ms and the slowest 1% increased by 150ms [7]. The increased connection latency was attributed to the increase in message size, which in my opinion is pretty interesting in consideration of the fact that we (generally) consider key size and operation speed separately.

______________

1. https://blog.wire.com/blog/post-quantum-resistance-wire

2. https://newhopecrypto.org

3. https://security.googleblog.com/2016/07/experimenting-with-p...

4. https://csrc.nist.gov/Projects/Post-Quantum-Cryptography/Rou...

5. https://newhopecrypto.org/data/NewHope_2017_12_21.pdf

6. https://web.eecs.umich.edu/~cpeikert/pubs/lattice-survey.pdf

7. https://www.imperialviolet.org/2016/11/28/cecpq1.html
There are plenty of reasons to learn a language - but Java in particular is a great learning tool. Whilst I don't enjoy developing in it (or its derivatives), I think that it's a great language to help people clearly understand control structure and polymorphism.

To this day, my experience continues to be that students who had a CS degree that included Java have significantly better fundamentals than those whose programme didn't. Whilst that's purely anecdotal, I'll definitely continue to skew this way until I see otherwise.
_The Fate of Africa_ is a comprehensive post-colonial history of the whole continent which does a great job with identifying overarching developments and spinning them into a narrative. It’s also very readable. I thoroghly recommend it.
Any fears of oracle stewardship?

https://www.google.com/amp/s/www.infoworld.com/article/32841...
That's a good point - it is highly dependent on what languages you already know from beforehand. If you know JavaScript already then it makes sense to learn a language that is not garbage collected, has no mutations or is not managed.

I would pick up Rust or Clojure before Java in this regard for example - though learning new languages gets way easier the more you learn.
If you tell your Java application server "here you have 4GB, use it as you wish" it will happily comply and trade memory for performance.

In most of the cases it's just a matter of setting a few Java runtime startup parameters.
It is a nightmare for cars, but navigation apps do make it an absolute joy for tourists. I can hop around with busses and the the tube like an expert. When on foot I can even find the most interesting detours off the most efficient route.

Cities like London prove that a city designed for pedestrians is better than a city designed for cars, for the simple reason that cars don't scale nearly as well as pedestrians and public transport.

Somewhat ironically, successful future cities are going to look more like London than your typical large US city. More walkable areas. More car restrictions. More car exclusion.
The it is cheaper argument works because the savings are short term, easy to quantify and the person making the open office decision can easily claim credit for them while the costs are long term, hard to quantify and difficult to assign directly to the decision for an open office.