skysight-inc/HackerNews huggingface dataset:
Looks like the product/engineering/creative focused time of Google is giving way to the metric/marketing/MBA/McKinsey people for a fully pedal to the metal push into their Ballmer phase.

When will technology/product/engineering/creative companies learn that the value creation is more important than the value extraction? With value creation there is always the ability to value extract. With value extraction the focus, and little research and development or innovative value creation, eventually it stagnates and sputters.

The product before the sales/marketing is key. A product of value can always be sold or marketed. You can't sell/market your way to a product.

As a developer, and investor, in Google this concerns me the move away from Alphabet, moonshots and research and development. The open mode is needed just like the closed mode [1]. The open mode is where value is realized, the closed mode is where it is produced [1]. Value is created in a state of play or creativity, this is usually the first thing to go in these phase changes at a company.

This happens at every company that creates immense value, eventually the research and development is hard to quantify the value so they cut and cut like Shel Silverstein's The Giving Tree, eventually it is just a stump and all the grace and built up value is tapped.

[1] https://www.youtube.com/watch?v=Pb5oIIPO62g
Some more practical tips:

Install the `hub` CLI[1]. Being able to fork, open and checkout pull-requests directly from the command-line reduced a lot of friction that I had.

Install the `h` tool[2] to automatically checkout repos in a fixed layout compatible with Go. `h org/repo` automatically clones and changes directory in one command. Instead of browsing a repo in the browser, use `h` and directly jump into the code.

Install the `vim-rhubarb` plugin[3]. This allows to select a few lines in the code and then type `:Gbrowse` to open the browser, with the same lines selected on GitHub. And then share the location to a colleague.

[1]: https://hub.github.com/

[2]: https://github.com/zimbatm/h

[3]: https://github.com/tpope/vim-rhubarb
And Russia has much more social liberties than the US does...
Montessori iirc
I love Paul Graham's articles, but isn't this Goodhart's Law but with more words?
(When a measure becomes a target, it ceases to be a good measure)
>Placing the head of Google, which contributes more than 99% of Alphabet’s sales, at the helm of it could call into question the entire purpose of Alphabet

I think this gives a false impression of the value of the non Google bits of Alphabet

Currently the market cap of Alphabet is $924bn and "Waymo is worth about $105 billion" (https://www.bloomberg.com/news/articles/2019-09-27/waymo-val...)
which would make that 11% of the valuation and probably other bits of other bets are worth something too.
I guess because they are only available in a couple of countries, are expensive, and Google isn't any better than their OEMs keeping old devices updated.
I think I get what he was saying. I would say the discounted number instead of saying anything about percentages. Round up whatever that number is to nearest hundred. Saying $x748.35 is your weekly rate does sound kind of sad versus $x800. As an example. Still sounds professional.
An important corollary is that school and tests teach you not to be wrong. They teach you that incorrect answers will be punished.

Yet, most interesting questions in life don’t yet have defined answers. Thus you need to have and test a hypothesis, which will very often be “incorrect” the first time around. But that doesn’t actually matter - the mere act of thinking about and defining what an answer could be sets you up to iterate and test. Eventually, you may find product market fit (a - not the - right answer).

You have to be willing to be wrong at first to learn...and win.
I think it is more management having fun and watching which dog fights better, what Android team thinks is less relevant.

Jetpack Composer is obviously they fighting back to the continuous flow of Flutter questions at Android conferences.
Yeah, Duolingo is definitely enough of a tool if you want to start to use the language in the foreign country, but it’ll be very obvious that you’re a beginner. I’d say that’s probably the best way to learn, but you have to be prepared to be very confused.
Also, notably, Luis von Ahn is the first Guatemalan unicorn founder.
JavaScript Is More Popular Than You Think
Waldorf/Steiner iirc
> Teich contacted the Guardian for help. We asked it to reconsider his case, and in an almost immediate U-turn, it has now agreed to pay all his legal fees, and has offered him £750 in compensation.

This is the unfortunate state of business. You’re fucked unless you can rake a company over the coals in a public.
You certainly can, but even Amazon had much higher revenue/funding ratio than Magic Leap.
I love JS but using it for content backfires as these examples show.
Then adopting a JVM language is probably not the cleverest idea.
It’s not the stability that bothers me but the fact that the comparison function is implicit and basically is

(a, b) -> a.toString().compareTo(b.toString())

Unlike say int.parse() where 10 is a reasonable default for radix, doing string comparison as default is almost never what the caller wants, so is a bad default. Functions where there is no obvious (99% of the time the desired value) should not have a default value when the argument is omitted. I’d much rather have things.sort() just fail and force me to specify the comparison, than to see it sort alphabetically.

As a side note: a second optional argument specifying stability true/false would be reasonable. True could be the default too, since unstable sorting is effectively an optimization with a tradeoff.
> I remember when I started I never knew what the "best way" to iterate on things was... for loops? for in? for of? foreach? And it was not obvious which one to use or what were the differences.

Possibly aside from the latter (assuming you mean Array#forEach), these are not different "methods with simple behaviour", they're different language constructs with largely overlapping behaviour & use cases.
The fact that you linked to an amp version of the page, instead of the real link, is deeply disturbing to me.

https://www.bloomberg.com/opinion/articles/2019-12-04/alphab...
I would argue dates with nanosecond granularity are of limited usefulness. In almost all use cases millisecond granularity is sufficient for dates, if you need nanosecond granularity chances are you also want a monotonic clock instead of real time that's subject to daylight savings, NTP correcting the clock etc.
So Kotlin/Native then.
I'm happy with OVH. But, I do agree that their support isn't always great. However, it's dirt cheap, so I adjust my expectations accordingly.

In the situation you describe, for example, it's not hard to add a new IP address in their admin panel and update DNS.
If the kid is doing the exactly same exercise for fun during holidays, then the issue is not the exercise is not interesting for that kid.

Most kids with good grades don't have tutor, unless they struggle a lot or it is before entrance tests for high school and college.
How do I get over the mental barrier of charging more than $100 per hour?

- I'm a junior developer and I mostly freelance for larger companies.

- I feel like $100/hour is the industry standard and if I charge 150-300 I need to do work that requires managerial work.

- 300+ comes from charging a percentage of revenue increase or creating such a narrative, which often requires additional business and strategic consulting.

- On the flip side, I enjoy coding and want to avoid additional managerial and business consulting as much as possible.
I completely agree with the the theory, however what 90% or more of us do when they finish university is to go work for an established (i.e. large) company, where winning means hacking bad tests (promotion cycles).

So in some perverse sense school does prepare most of us well for working life, as most of the time doing well in BigCo isn't to actually perform well or to actually make a difference, it's to leave the impression of it at the right time with the people that matter for your next promotion.
Several schools of economic thought claims "Money" also operates as a test for "value for society". It's also as porous as a colander.

> I suspect many people implicitly assume that doing working in a field with bad tests is the price of making lots of money.

> Now you can make lots of money by making cool things.

An analogous set of incentive structures, which compels people in elite universities to play the tests applies to intra & inter-company interactions as well: companies who play for the tests will enjoy structural advantages over companies which do not; and this lever allows winner-takes-most mechanisms via buyouts, consolidations, private equity.

While founders, individually, may make out of this wealthy, companies, and society as a whole suffers, and playing for the tests, as a behavior, saturates.
I’ve been a happy Dropbox customer for years and I was happy to pay the recent price increase in return for more space... but I can’t help feel that the company has been burning a lot of investment doing random stuff that I don’t care about, while core features go neglected. My pet peeve example being: why does Camera Uploads not upload Live Photos from my iPhone? Google Photos manages to do it.
Do not think in hours. You are not a worker in a factory. Consider the value you deliver. When you deliver twice the value in the same time you did a year ago charge twice as much.
I outsource a lot of game dev related work. Usually I give the requirements, ask for an estimate from the contractor then I increase it 25% and ask if they’d do it at that fixed price. Does that seem fair? So far it seems to have worked out over a few tasks but curious what objections you or others reading might have to this?
I don’t know of any good articles about the trade-offs of the various approaches, but I’ve started writing one myself. (I’m drafting a series on the intricacies of various UI patterns and their implementations, and this was actually already on my list.) Email me if you’d like me to drop you a line when I publish it (being realistic, expect to wait weeks for it).
Retraction Watch says "hello".
> To me the moment you're trying to defend Java generics and type erasure, vs C# which paid the price early and has reaped the rewards for years, you should already you're on the wrong side of things...

Those erased generics that you call "half baked" are the reason why language interop works so much better in Java that in .NET. The combination of subtype polymorphism and parametric polymorphism means choosing a variance strategy. If you reify generics with subtypable arguments that means that you must bake a variance strategy into the platform -- which is what .NET has done -- even though languages have very different ones (in particular, untyped and typed languages will have different variance). So on the Java platform, the Java language, Kotlin, and Clojure all have different variance, yet they can share data structures with no runtime conversion. The cost of this platform compatibility is exactly three very minor annoyances [1] in the Java language. For the price of these three minor annoyances, the reward Java has reaped is a large polyglot ecosystem that's a favorite of language implementors. The Java language, too, the one with those actual three minor inconveniences, is also much more popular than C#. So overall, I think it is hard to argue that C#'s rewards from reified generics are greater than Java's from erased generics.

It really doesn't take much of an effort to defend Java's choice once you know what the ramifications are and what the results have been. Partly because of the mistake of reified generics, .NET is de-facto a one-language platform. The language, like most programming languages, is fine, but given Java's growing emphasis on being one of the best runtimes for Python, Ruby and other languages as well, it's very clear that the two platforms have very different goals. Reifying subtypable generics is a good choice for a one-language platform but a bad choice for a polyglot one.

[1]: In order of decreasing annoyance: no overloading by generic argument, no `new T[]`, no `instanceof List<String>`. All three are very minor concerns, and the last is possibly even an antipattern.
The worst actor in this the person who refused to return the mistaken transfer. Why isn't he or she going to jail or at the least being sued for legal fees? Why does the article only talk about corporate sloppiness but not personal misbehavior? Why isn't the law changed so that people getting mistaken transfers can be identified quickly if they do not return the money?
You're not wrong, but I think starting with structuring data to be reasonably performant is always the best first step. You can always make it deferred later if you want or need. This way you don't hammer your DB and leave weird structural issues in your model.
Apple is investigating a popping sound issue with the new 16-inch MacBook Pro
I wish there was some paper that would quantify the dangers of this take over down into hard numbers, so that they could be used in the never ending internal civil wars of value creation vs value-usage.

In a ironic way though, this life-cycle reflects what we humans go through though. We have a fragile phase, where we must find our place, develop new things, risk it all, then we settle in, apply the learned things to our conquered niche and set to full cruise mode, to produce turtles eggs, to repeat the cycle.

So if a society wants to propell the exploration onwards, there are two ways. Eternal youth, as in never growing fully up, always replace aging elements with new rebelious and clueless young elements. The other, is acclerate the aging &reproduction period. For example allow for Managers, who can proof that there company is stagnant- has a stranglehold on a market, to split a sub-department from the main company (including IP) and thus accelerate the new turtle baby phase.
FWIW, I could have produced an equally-long list of Java flaws. I'm not terribly attached to either language. I just wanted to challenge the meme that "C# is a better Java" I hear on the Internet every other week.

"Infinitely" more useful seems like a stretch. Both languages made valid design decisions with their lambdas: autogenerated types means not every variant of lambda needs a backing interface, but it also means that the types are a world unto themselves and not integrated with well-established interfaces and abstract classes in the way that Java lambdas are, resulting in conflicting mechanisms for passing code to adhere to a requirement. I find the unification of SAM types and lambdas to be elegant in a class-based OOP language (and actually preferable to the Smalltalk/Ruby block model too), but it's clearly subjective.

My criticism of properties hiding side-effects as attribute reads is mostly derived from one of the earliest books about the CLR; was it "The CLR via C#"? I'll have to check. The critique isn't Java-inspired; getters have the same problem of course. The point is that a getter is a method call, so you expect potential side-effects. You don't expect side-effects from a property read, although C# does tend to use capital letters for properties, to be fair.

While on the topic of CLR, I realise the DLR exposed dynamic typing primarily to make the CLR a better target for dynamic languages; I was arguing that exposing that up to C# wasn't necessary. C# is the flagship CLR language, sure, but that doesn't mean it must expose _every_ feature of it. Java also added `invokedynamic` for similar reasons but didn't feel the need to expose it to its flagship language directly in language syntax.

pron covered the nuances around generic type erasure in another comment better than I did, so I won't reiterate. Like you, I still mildly prefer reified generics over erasure as a language user, but the points raised by pron and Bracha are absolutely real. The ability to do runtime type checks and default values on generics seem like antipatterns, so I'm glad Java doesn't support those _specific_ features of reification even if I like a lot of the others parts.
I'm not sure how they are pretending? The AR bit seems to work pretty well to me.
Stealing from a bank is no more defensible than stealing from an individual. Banks have people behind them -- shareholders, creditors, and employees.
the last time I checked the CTO of Tesla said that vehicle2grid had negative return on investment but that might have been politically motivated.
Clojure devs tried to make something like that with edn and transit IIUC
You're misreading the article section, although the article is also partially wrong: the old behaviour was to output the lone surrogate in the JSON stream[0] (the "�" here is confusing: it is a display artefact of the specific font, not U+FFFD), the new behaviour is to replace the unpaired surrogate by the literal 6-character long escaped representation of the unpaired surrogate.

That is, formerly U+D83D would pass through straight as U+D83D (or possibly be replaced by U+FFFD in some implementations), whereas it is now "encoded" as the sequence U+005C U+0075 U+0044 U+0038 U+0033 U+0044.

That is, the entire point of the "well-formed stringify" proposal[1] was to stop generating broken JSON:

> Rather than return unpaired surrogate code points as single UTF-16 code units, represent them with JSON escape sequences.

[0] it's possible that some implementations would replace the lone surrogate by U+FFFD but according to MDN:

> Before this change JSON.stringify would output lone surrogates if the input contained any lone surrogates; such strings could not be encoded in valid UTF-8 or UTF-16

this is also the behaviour I observe on an old safari, and the one which is quoted in the tc39 proposal[1]:

> JSON.stringify can return strings including code points that have no representation in UTF-8 (specifically, surrogate code points U+D800 through U+DFFF). And contrary to the description of JSON.stringify, such strings are not "in UTF-16" because "isolated UTF-16 code units in the range D800₁₆..DFFF₁₆ are ill-formed" per The Unicode Standard, Version 10.0.0, Section 3.4 at definition D91 and excluded from being "in UTF-16" per definition D89.

[1] https://github.com/tc39/proposal-well-formed-stringify
The Baby Names That Defined the Decade
That would require significant effort for the vendor to set up and most internet devices such as routers are an absolutely minimal cost device. Literally every cent counts in production and vendors rather remove some features than shell out the 2 cents extra to add another 64mb of storage.

Furthermore, this would require either not being able to change the IP for your device (bad) or sending information about the layout of your network to the vendor (I wouldn't trust them with that info).

Very few people care about this and the effort of maintaining a custom DNS and a CA certificate system (which, by the way, would need to be subjected to rigorous security testing) just isn't worth it.

Lastly, what's the point? Adding a little padlock isn't worth it if anyone can get a certificate for the router ip anyway. How do you ensure that the router connecting to your IP really has the mac address it claims? It only takes one person to get root on their router to invalidate the entire security system and given how somehow router vendors are still shipping command injection vulnerabilities, I wouldn't assume that they can prevent that as much as they'd like.

What I want is the option to give a router my own security certificate instead of the self signed one. Let me use my own CA or let me mess around with letsencrypt, split-horizon DNS and Selenium scripts if that's what I need. Consumers don't care about TLS on their router and this would be the cheapest option to solve it for prosumers.
Popularity of Baby Name (Ssa.gov)
You have more than one real fingerprint, too.
Implicit Subsidies for Cars
Maybe a better way to put it is I'm more forgiving of myself.
Agreed. This is a poor schema made worse.

Querying the json is why this is slow. Pull that garbage out of the json and into a couple of tables and you'd be much faster.
In angular 1, if you had a function on the form

myApp.controller('MyCtrl', function($myCoolService) {
//...
});

Angular would see that you are looking for a parameter named myCoolService, see if it already has it, and then inject it when calling your controller.

This of course broke in various ways with minification when the parameter names were mangled. So one had the opportunity to use "array syntax", requesting a dependency by a string. Or use a preprocessor in the build script adding the array syntax before minifying.
Fair enough; I do miss keyword and default arguments from C# when using Java. A long list of overloads and argument forwarding to fake default arguments gets old.
Why was Rasmus so concerned about reverse DNS? That's not something I'm very familiar with. Can anyone help explain?
I write Kotlin in vim, so it's not all devs using Kotlin.
I believe Firefox adds random delays, if you enable one of the Tracking Protection settings.
The most feasible nuclear plan I've heard involves mass produced nuclear plants being moored offshore from population centres.

They can be built in one place and towed to where they are needed, towed back for repairs or upgrades.
The favicon is KILL M$
When you charge low rates people will assign low value to your work and assume that you are entry-level.

Even when they know your work is of good quality they will think that by being unaware of its worth you are probably not very experienced. Last but not least you of course get exploitative clients that way.

The worst thing you can do is offering free work for "friends". Often they will not even say "thank you" or use the actual work you delivered.
This. If I had started back in ‘11 or ‘12 instead of ‘18 I wouldn’t have a mortgage right now.
Yes, most tests are bad, but there is a quick advice that improves them immensely: never ask questions that are not at least Level 3 in Bloom's taxonomy of knowledge: https://blog.testdome.com/blooms-taxonomy/

I cofounded a technical screening startup, and despite our efforts to educate our customers that enter their questions on our platform, 95% of their custom questions are bad questions. They tend to ask trivia questions, that can quickly be googled, instead of asking work-sample questions (which we at TestDome.com prefer). I think they learned that from years of paper tests in school, it is very hard to unlearn.

Just to give you an idea, for testing web programmers we suggest questions where you need to find bugs in HTML code (https://www.testdome.com/questions/html-css/inspector/17629), while our customers would ask questions like "What does CSS stand for?"
Thanks a lot, didn't know about temp functions. You're hitting the nail on the head with where I want to go with this. I wish postgres put more attention into this kind of interfacing layer.
Is there really a market for a self hosted B2C SaaS options? Would it be enough of a differentiator to drive business away from competitors?
If people don't like doing it,then they need to make sure the entire internet knows about them: bligs,articles, etc. This is one of the ways for introverts to deal with it.
Tesla starts charging $10 a month for connectivity
Yep, I just found out about temporary functions today. Gonna start experimenting with that.