vorg

> you give the same money to everyone, even if they're a billionaire. To make up for this, you raise the taxes a commensurate amount on the people who don't need it (and more for the really rich people, because the idea is wealth redistribution

This has already happened in various countries like the UK until the 1970's. In New Zealand the top income tax was 66%, and a "UBI" for everyone 60 and over, regardless of their income, was introduced. Of course those with high incomes paid up to 2/3rds of this back to the govt as income tax. In the 1980's, NZ followed the UK in slashing income taxes to the levels found in the US. The qualifying age for the "Universal Basic Income" was progressively increased to 65, with tentative plans to raise the age even further in the near future.

If the experiment there was to be extended, then the top income tax would have remained at 66% and the qualifying age for this "UBI" progressively lowered in stages down to 18 as the country could afford it. To see why the experiment was cancelled, I think we should look at why the income tax was lowered in these countries. Perhaps the rich lobbied for less taxes, and threatened to shift their businesses to Australia and other countries.

> A State Council document, issued in July last year, resolved to position China as the world’s pre-eminent practitioner of artificial intelligence (AI) in both research and application within the next 12 years.

The language sounds just like Japan's MITI-run 5th generation project in the late 1980's, where they planned large-scale use of Prolog to replace their country's "antiquated" IT systems written in languages like Cobol and C. Using Prolog didn't quite work out the way the Japanese expected. Perhaps the Chinese have similarly overestimated the true potential of AI.

Android isn't just Kotlin and Java. It also bundles Gradle with its Apache Groovy DSL, whose syntax is just as esoteric as Swift. Although Groovy is pitched as having Java's syntax, the DSL portion of it (as used in Gradle) looks nothing like Java.

Candidates often turn up in person to the interview with their new manager, but send a double to the aptitude test which is only supervised by HR staff. Because HR often get bonuses based on how many new recruits they bring in, they often skip ID checks and turn a blind eye to anything suspicious they see.

I like programming in Clojure -- it's the language that introduced me to lisp syntax and immutable values. But Scala has been adopted and Kotlin is being adopted to a far greater degree than Clojure seems to have been.

> Clojure, Groovy, JRuby, Jython are popular dynamic languages on the JVM, there are others

Perhaps he meant no dynamic languages have become popular enough on the JVM that it becomes common knowledge that the JVM can support popular types. None of those 4 languages you mentioned (Clojure, Apache Groovy, JRuby, Jython) are popular, whereas alternative JVM languages built from the ground up as static languages (i.e. Kotlin and Scala) are the ones people are adopting.

My last two IT jobs ever were both for businesses which cancelled huge rewrites after being sold to another company. Someone up top pitched the businesses as white elephants ripe for massive cost savings half-way during the rewrite.

The programmers with the political skills to get put in the "Rewrite team" will have had their jobs in the "Legacy team" protected in case of project cancellation. Or they will knife you in the back to get their old jobs back -- they will know about the cancellation and have plenty of time to maneuver before you know what's going on.

Instead of `it` for one, and `this` and `that` for two, use `este`, `ese` and `aquel` for three (from the 3-tier pronoun system in Spanish).

Please don't ask what if there's four. Very few (if any) natural languages have more than 3 tiers of demontrative pronouns, so computer languages shouldn't -- if they're using ideas natural language to be more readable. They would use identifiers or numeric subscripts instead.

If there's one condition, use `it`. If there's two, use `this` and `that`, i.e.

  if (a == 3) || (b == 4) delete this //to delete a

and

  if (a == 3) || (b == 4) delete that //to delete b

If you want to delete both if either is true you could write:

  If (a == 3) || (b == 4) delete them

I believe Swift (I think) uses this idea, where the 2nd and subsequent parameters are often named prepositions:

    divideInto(x, by:y, mod:z)

Sounds like Prolog.

> Not useful at all

In English, nouns are often spoken with stresses in a sentence, which could make capitalizing them a pronunciation issue, just as other punctuation is (e.g. commas for pauses, question mark for changing intonation). I don't know about German, though.

You could be talking about Apache Groovy's seamless interoperability with Java 7. It hasn't kept up with Java 8 and lambdas, let alone Java 9 and modules.

> My current direction, which I was all set to get serious with today, was to use Groovy on Grails

Is that version 2 or 3 of Grails? Virtually no-one has updated their Grails 2 websites to version 3, or is starting new projects in Grails 3. Choosing version 3 means first adopter risk.

Kotlin's the latest in a long series of leading alternative languages for the JVM, each having a turn taking second spot behind Java. First there was Beanshell adding syntactic shortcuts for property boilerplate, then Apache Groovy came adding closures, then Scala took the adoption lead adding full static typing and heavy functional capabilities, and now Kotlin's come into second JVM spot with simplicity by removing cruft. So think of Kotlin as "alternative JVM language Two point Oh".

I imagine Android Studio will switch to Bazel sometime in the near future. Every other non-Android Java shop seems to be rewriting their Gradle build files as Bazel configs nowadays. Gradle and Apache Groovy just don't scale.

Seems like every other site is converting its Gradle builds into Bazel.

> a Jenkinsfile[0] where you get a complete groovy DSL

Apache Groovy isn't "complete" as shipped with Jenkins. It's collections API is deliberately crippled so it doesn't work.

The U.S., like Canada, Australia, Brazil, and many Spanish-speaking countries in America, along with the former colonizing countries of Western Europe (e.g. England, Holland, France), is an immigration-based country, and so birth rate is only one factor. Given the number of people from China, India, and elsewhere who would immigrate to the U.S. if they could, it's not inconceivable that one day the U.S. will welcome them and their money so Americans can profit from another residential property Ponzi scheme.

It would be nice if downvoters had to add a compulsory comment, though I suspect many users would create a special login they use just for downvoting. HN is a lot better than other sites though, such as Reddit, where some subreddit moderators often delete comments after you've replied to them, leaving your own reply as an invisible orphan.

> Groovy, for example, is as popular as Scala or Kotlin

Things have changed in the past few years. I would now put Apache Groovy in a different tier than those other two. Kotlin's rise has been at Groovy's (as well as Java's) expense. So nowadays I would rank JVM language adoption as these tiers:

  1. Java
  2. Kotlin, Scala
  3. Clojure, Groovy
  4. others, e.g. JRuby, Ceylon

> overestimating importance of the build system

True. Gradle (and its Apache Groovy build DSL) conquered a market by first creating that market. There's really no need for a build system with a procedural build language -- a declarative language to describe a build like with Make and Ant/Maven is good enough.

> gradle, maven, xcode, it does not matter what target is or what source is (as language

But it does matter what the language is for the build script for each build system, e.g. Apache Groovy for Gradle, XML for Maven.

The docs at http://vertx.io/docs/ are available in different editions depending on what language you use with Vert.x, of which there's 7 available. Besides JavaScript and Kotlin, there's also:

  Java
  Apache Groovy
  Ruby
  Eclipse Ceylon
  Scala

> half of your logic is second class code-as-a-string (e.g. trying to work directly with Gremlin Server from a non-JVM language by POSTing Groovy-as-a-string

It must be particularly difficult when your Groovy-as-a-string script itself has many strings in its code, which is what a typical Apache Groovy build script for Gradle looks like.

> It uses by default BigDecimal and BigInteger for literal numeric types

Apache Groovy uses by default BigDecimal for literal decimal types, but only uses BigInteger for literal integral types when it would overflow the largest available primitive type for that literal. You can force a BigInteger by using the suffix `g` on the integral literal. Perhaps misunderstanding this is the source of some hard-to-find bugs in some of your Groovy code.

The distrust of anything "not invented here" is prevalent in big corps like Google.

> Modern languages are all converging to the same good feature set but don't have anything to differentiate from each other

You said "good feature set" rather than "feature set". I'd agree those languages are converging to the same feature set, but the features they're each really good at does differentiate them. Typescript is good for Javascript generation. Kotlin and Eclipse Ceylon are good at generating statically typed JVM bytecodes. Apache Groovy's good for those 20-liners in Gradle for specifying builds on the JVM and Android. Kotlin's good for Android code.

> Newton, Pythagoras, Socrates, columbus, genghis khan, soviet union, Mao

Not sure why you didn't add some example pertaining to the U.S. such as:

"Or how the United States promotes freedom of expression while locking up over 1% of its adult population."