skysight-inc/HackerNews huggingface dataset:
Your version written in Java

private static final int[] VALUES = range(0, 16).map(FizzBuzz::fizzbuzz).toArray();
private static final int[] DELTAS = stream(VALUES).map(v -> v < 0? 0: 15).toArray();

private static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_256;

private static int fizzbuzz(int i) {
return i % 15 == 0? FIZZ_BUZZ: i % 5 == 0? BUZZ: i % 3 == 0? FIZZ: i;
}

public static int[] simdFizzBuzz(int length) {
var result = new int[length];

var v1 = IntVector.fromArray(SPECIES, VALUES, 0);
var v2 = IntVector.fromArray(SPECIES, VALUES, 8);
var d1 = IntVector.fromArray(SPECIES, DELTAS, 0);
var d2 = IntVector.fromArray(SPECIES, DELTAS, 8);

var i = 0;
var upperBound = length - length % 15;
for(; i < upperBound; i += 15) {
v1.intoArray(result, i);
v2.intoArray(result, i + 8);
v1 = v1.add(d1);
v2 = v2.add(d2);
}
for(; i < length; i++) {
result[i] = fizzbuzz(i);
}
return result;
}

quite cool indeed
Diet Pi version 7 released
Dismissing a 100,000 foreign individuals crossing your border as "a bunch of kids" is even more disingenuous and further fuels the issues the anti-immigration folk have. 100,000 is not peanuts. As the other commenter mentioned, that's a bigger than probably hundreds of towns in the USA.

Anywho, if we really "cared" about all the "bunch of kids" suffering in Mexico, we would have invaded Mexico and installed a "democratic" government years ago.
We often talk about the rule of three in software development. The idea is that you don’t start looking for abstractions until you have at least three instances where that abstraction will be useful. The problem with component based or semantic CSS is that it forces you to define abstractions for everything up front even if n=1.

The beauty of Tailwind is that you can still define abstractions when they are needed and pay the price of using abstractions but you can also handle the many one offs every site has in a much cleaner and more direct way.
How to change SKU when selecting different variations in Woocommerce
I sigh with relief when I see retro installers like that - at least you know it will work!
Stimulus Reflex for Django
My experience is the opposite. Most bread recipes for example are both incredibly tolerant of mistakes. Also — flour varies so much in capacity to absorb water and gluten content between brands that I'd say precision is very much illusory unless you are after industrial-style consistency.

Small changes in how you handle doughs of different hydration, and changes in timing/temperature thereafter have a much bigger difference to the outcome. I think it's better to develop an intuition for what the right consistency is and work towards that.
China’s $4k electric cars tap huge market Tesla can’t reach
> Trying to encourage people to enter into an endless game of Whac-A-Mole fixing and re-fixing browser extensions to work with sites as they update isn't a solution.

Sure it is. This is called adversarial interoperability and it is great:

https://www.eff.org/deeplinks/2019/06/adversarial-interopera...

People are going to fix bad websites whether or not their owners want them to. This is exactly how ad blockers work and they solve so many problems with the web it's not even funny. I've posted many times about how we should just stop trusting hostile website javascripts and start writing custom free software scrappers or clients for all of them. I suppose GNU had the same idea. Awesome!

> Who here is going to spend countless hours on that thankless task?

I spent quite some time writing my own JS code for my school's portal because the default site was unusably bad. The results were pretty good and lasted until months after my graduation. If everyone did this, the web would be fixed in no time.

Why should we allow companies and web developers to have the ultimate say in how their sites work? The javascript is running on our computers and we can totally replace it if we want. We are in control and it is time to start exercising this power.
It means it lives on the stack, so it "exists" until the function returns.
It doesn't do type deduction there.

In original C you could declare variables without a type, and these variables with auto have no type.

So this "auto" is essentially saying "this variable without a type uses automatic storage". That's a completely different language feature from "deduce the type of this variable".
Top Big Data Trends to Dominate 2021
> Perhaps there should be a required banner for every JS-using site, telling the user that it sends you executable code, and you need to press a button to confirm that you indeed want to let the browser do that. (joke)

IIRC, this was exactly what we had in the old days of IE4/IE5. Also for cookies, even earlier than that.

(We sort of got cookie popups back, thanks to it being easier to throw a popup than to actually obey the spirit of GDPR and be a good web citizen. I wonder if at some point same will happen with JS?)
Because when we were teens and younger programming, we were just covering well-known ground, learning to program and messing about. Some useful stuff maybe, but not furthering Computer Science with ground-breaking research. No different to playing an instrument as a child for example.

The doubt isn't over whether a teen can do 'basic chemistry', it's whether they've 'invented' something; whether they've done anything that someone who doesn't know them/their family/their school and isn't considering their application for something needs to care about. It's whether this is (or was a while before the media got it) news or exciting or a citation for an adult researcher working in the field.
One secret weapon against extremism: Google ads promoting mindfulness
> There will be no issue in terms of program correctness

there is if it leads to deadlocks.
It would become distributed DB on top of super solid foundation that powers snowflake, icloud etc.
I have been using Tailwind CSS for about a year now, both on my own product and 2 products from 2 different founders I work with from On Deck.

Here is what I have to share:

1. Tailwind Makes Your Code Difficult to Read

Tailwind CSS, in my opinion, is the easiest to read and understand what is actually happening. Yes I agree there is a learning curve to the shorthand notations but the naming is not bad at all as the author says. A couple days of light use and the system was in my head. Saying this as a full-stack engineer who deals with React + Python and devops. So I do not ONLY look at CSS shorthand notations all day.

The example with the really long string of Tailwind CSS classes do not occur with me since such a complex string of classes is probably going into a component that needs customization from React component parameters. So I build the Tailwind CSS class names line by line with if-blocks or similar.

2. Tailwind Is Vendor Lock-in

"Once you build an app with Tailwind, moving it to any other CSS framework or library in the future is going to be grueling." - the whole point of Tailwind CSS is not to move to a framework. Your JS components mixed with the CSS are exactly your own branded framework. I am not sure I understand the move argument.

Even though all the products I work with are small, we have new frontend engineers helping out and it took them less that an hour to find the right Tailwind CSS class and making pixel-perfect components. This is close to CSS yet comfortable to see and existing project and contribute.

3. Tailwind Is Bloated

Purged Tailwind CSS based stylesheets are ridiculously small. Try it out for yourself. (1)

4. Tailwind Is an Unnecessary Abstraction

Again, like I mentioned, I was even nervous that new people will not like the abstraction that Tailwind CSS has. But once you see an existing, well setup project, its so easy to check documentation and contribute. The abstraction is super thin on top of CSS.

"If it’s not already obvious, @apply completely violates Tailwind’s founding and guiding principles." - no it does not. Tailwind CSS exists to create your own style framework. It is that simple. Once you see patterns, you use @apply to codify them and reuse. That is so convenient. It is a feature in my opinion and a really important one as your project grows.

I want to stop here, but I feel that these 4 points are not strong counter points to someone using Tailwind CSS for a year over a few projects now.

(1) https://tailwindcss.com/docs/optimizing-for-production
What's your stance on accessibility? I'm worried this tool could be used by enterprises, considering their reliance on VB, so this is pretty important IMO.
See also https://news.ycombinator.com/item?id=22545878 [Show HN: FraidyCat, 800p]
I think it's the exact opposite. Having maintained some else's CSS on dozens of projects, Tailwind is soo easy to keep maintained.

You don't have to learn some else's idea of what CSS belongs to a component and how they structured it. You just go into the HTML, add or remove a couple of tokens and you can be sure yoyu didn't break anything else.

Once you've learned it - which doesn't take very long - it scales to other projects. You don't have to relearn - again - what someone else thought would make a good CSS abstraction for their UI.
Important to note there are two 'flavours' [with a fecking U!] of English. So, even if you're a native English speaker, it can be almost as frustrating, as most programming languages are written in US English. So, if you're the kind of person who takes a pride in your spelling and grammar, there's the constant thorn in the brain of having to deliberately spell words wrongly all the time, such as needing to write:

color instead of colour

center --------> centre

math ----------> maths

And then these new-fangled languages [like Crystal] come along and add to the misery with their:

fiber ---------> fibre
Electric Cars Are Coming. How Long Until They Rule the Road?
Why data gravity won't stop the move to multicloud
How to get modified records in the last hour using SOQL in Salesforce
I bought 300 emoji domain names from Kazakhstan and built an email service
On the other hand, I quite like Tailwind because if I'm looking for a CSS option, it's more discoverable than raw CSS, "text-", "bg-" and so on. It's consistent.

As for 'it makes your code harder to read', I simply write the classes in HTML, then when done, move them to my CSS file via @apply, and my HTML looks the same as it has always done.
Good variable names (and type names) matter for legibility. They should be clear, unambiguous, short, memorable and suggestive. Unambiguous is usually more important than short and memorable.

The word 'long' is ambiguous and unmemorable. And the type "word" is actively misleading. If you called a variable or class 'long', it wouldn't pass code review. And for good reason.

'Power' is an excellent example of what good technical terms look like. "Power" has a specific technical meaning in each of those fields, but in each case the technical meaning is suggested by the everyday meaning of the word "power". Ask a non-physicist to guess what "power" means in a physics context and they'll probably get pretty close. Ask a non-programmer to guess what "integer" means in programming and they'll get close. Similarly computing words like "panic", "signal", "file", "output", "stream", "motherboard" etc are great terms because they all suggest their technical meaning. You don't have to understand anything about operating systems to have an intuition about what "the computer panicked" means.

Some technical terms you just have to learn - like "GPU" or "CRDT". But at least those terms aren't misleading. I have no problem with the term "double precision floatingpoint" because at least its specific.

"long", "double", "short" and "word" are bad terms because they sound like you should be able to guess what they mean, but that is a game you will lose. And to make matters worse, 'long', 'double' and 'short' are all adjectives in the english language, but used in C as nouns[1]. They're the worst.

[1] All well named types are named after a noun. This is true in every language.
Cisco voice / video products feel like they're designed to look good on a product comparison chart rather than to provide a robust user experience.

It's so hard to explain to senior decision makers about why the cisco product should be replaced because on the surface it looks like cisco does everything that the competitors do.

And large companies can't easily compare KPIs for a product they already have against the unknown third order effects of a competitor's product. Cisco knows that so they keep doing the bare minimum.
Don’t expect Tesla’s ‘Full Self Driving’ to come out of beta any time soon
How about just giving CSS a tag to vertically and/or horizontally center multiline text in a box, without needing constructions involving multiple elements. Preferably with a simple name like "center" or "middle", though unfortunately those two names are already taken up by things that do not actually put the thing in the center or middle.

Original HTML could do it in table cells. What's taking CSS so long.
As others have said, I wouldn't worry about C++ going anywhere soon. The sheer amount of historic code out there, and the difficulty of replacing that code with any of the potential alternatives mean the language is still likely to have decades of life in it, even if it did not continue to change and evolve.

Whether a change to more C++ development will be good for either you or your team is a more open question. I was primarily a C# developer and got into C++ because I ended up in a company where it was being used and had to be supported. I have never coded in Swift and have done almost nothing with objective C, so I will not comment on them. I have been coding periodically in C++ for the past five years, and to me it always feels slower, more difficult and less enjoyable to write something in C++ than to do the same thing in C#

It is true that C++ is a powerful and flexible language and there are places where you will be hard pressed to find anything that works as well as it in terms of raw performance or fine grained control. But because of its age, many features which can be taken for granted in a language like C# have had to bolted on to C++ and lots of those bolts look ugly. There is also a lot in the language, and if you're going to use a language feature then it really helps to understand it in depth, because its depressingly easy to write code that is badly wrong in ways which will not be easy or quick to detect.

If your team's need for C++ support is going to be a long term thing (ie they're still going to be needing you to work on this stuff a year or more from now) then it may be worth their time and yours bringing you in to work on the language. If not, you may well cost more in terms of what it takes to get you up to speed than the benefit once you are fully productive. (This, of course, will vary depending on many factors such as the quality of the code base, the range of language features it happens to employ, the amount of support you can expect from your co-workers and how competent you are at learning a new language. These are things that only you and your team are able to decide.)
Analogous != same. The differences can easily cost a large fraction of productivity for a certain period of time (a couple of months?).

Would I hire a bright candidate that require retraining given absence of those that do not? Quite likely yes.

Would I be pissed at false advertising? Again, yes.
Look into https://awesomecpp.com/
And purge css is not some "other thing" you have to go get to use tailwind effectively, it's built in! You don't need webpack in the mix or whatever, you just need a couple of lines in your tailwind config.

In real life, tailwind produces the smallest dist files of anything I've used just because the built in treeshaking thing is just effortless and works so well.

(Clearly this is my least favorite "I don't like tailwind" gripe lol)
I’ve built big sites this way too and it’s a small improvement over pure CSS methods but still much less productive and maintainable than the utility approach.
Exactly. Tailwind is remarkably consistent and discoverable. There's a plugin for VSCode that gives you completion.
Having to use an async immediately invoked function expression in Node scripts is kind of a pain, but I agree.
This is food-as-fandom, isn't it? It's not enough to enjoy your own tastes, you have to get out there and tell people that your taste is superior to theirs. You can see it playing out even in this thread.
I wonder if they’ll ever launch real-time videoconferencing
By Allocative efficiency.(https://en.wikipedia.org/wiki/Allocative_efficiency)
So, we're in Switzerland and finding a used one was not that hard. We decided on few must have things (shower, toilet) as we didn't want to do a substantial overhaul and we visited in person some dealerships. About the modifications, we bought everything from https://autosolar.ch/ and the increased water tank is basically the original one (40L) plus 2 20L containers.

About the living in it for months it takes some getting used to. Especially when the weather is bad. Being confined in 10 sqm with another person is not easy. We didn't jump in this adventure straight away, but we eased into it with long weekend trips and then 1/2 week trips. When everything became second nature we were confident we could do it and started planning the trip.

Lessons learned:
1) get at least 2 compression bags for dirty clothes. No normal bags, but compression ones. And you wash them with the clothes.
2) Buy a small de-humidifier. We had some mold problems when we encountered some long spells of bad weather.
> Are we now at a stage that .com is no longer considers more 'trustworthy' than say .xyz?

Generally, I'm not sure. But I (and I think the majority of the people I know) were beyond that stage a long time ago or never cared/understood to start with. As you mention, not being in the US might bias my opinions and the opinions I'm exposed to on the matter, so YMMV.

I'm not sure if it confers any SEO advantage, but I don't particularly care about that (the things I have hosted are only useful to people who already know about them, so SEO isn't a concern).

> trustworthy

That might be the wrong concept for the discussion though. Another key factor is whether somthine.com is more memorable or guessable than something.co.uk, something.site, something.link, ...
I never got the point of Tailwind: having an element with utility classnames on it that each add one CSS rule, like class="flex flex-wrap" doesn't seem any better than just having the equivalent inline styles on it. Sure, the Tailwind utility classes are shorter, but the abstraction doesn't simplify anything. It's just some set of aliases you'll need to have memorized, and it's just moving the one-off combining of styles from the inline style property to the class property. It seems like something built to superficially follow the common wisdom of avoiding overusing inline styles.

I want to echo the author's recommendation of styled-jsx. I've been using it with React for a few years now and love it. Like Tailwind, the styling is conveniently co-located with your elements, but it's just regular CSS properties with their full power instead of a set of aliases crammed into the class property. It also encapsulates the styles to the component's own elements by default, which is very good at encouraging making encapsulated components. The codebase I'm working on used to have a mess of CSS files, and CSS files for various screens often messed with the internal styling of common components used within the screen which would regularly cause us surprises whenever we updated those common components without realizing how they were abused across the application. Now that we're using styled-jsx, proper component-level encapsulation is enforced by default, and it really helps guide us toward making the components themselves be responsible for their own styling needs, which keeps things much more understandable and more local with less "spooky action at a distance" (external styles modifying the component's internals).
I tried the 'functional CSS' approach a few years ago and whilst at first I found it pleasurable to use, I ultimately grew to hate it. The biggest pain-points for me were exposed when returning to older code -- parsing the intertertwined mix of utiltiy class names and html added a level of overhead that I didn't have before. Additionally, later on in projects I'd encouter more edge cases where I need to provide bespoke styling for certain elements. As soon as you need to mix functional with traditional CSS I found the overhead to increase further.
GitLive 11.0: Real-time merge conflict detection
The original article was mainly centered around javascript, where you cannot spawn an executor to synchronously get the result of an async function.
> The real killer is when I'm trying to prototype. If I don't already know what my interfaces are going to look like, Rust really slows me down.

This requires practice, but given the choice, competitive programmer teams picking Rust do quite well in competitions (ICFP has been won by teams using Rust 3 years in a row, and in the last 3 years, two teams in each year's the top 3 used Rust): https://www.reddit.com/r/rust/comments/ctzmo2/icfp_2019_prog...

There are teaching materials for competitive programming with Rust, you might want to check those. I think they are a good way to learn how to "prototype" in Rust.

It's different enough from other languages that this is a skill that must be actively learned :/
You're right - I think a lot of people don't care.

However even if you take out the replaceability I still think that there's a relatively limited upside.

Thus you're left with conscience or a sense of professional pride as motivators to write docs.
transmission-daemon with the web GUI.
> your app doesn't talk in SQL, it talks in Objects

Maybe that's the problem? It might just be that OOP is a poor fit for large datasets :-/

Using OOP for results from a RDBMS is banging a square peg into a round hole: with a big enough hammer you'll eventually get it in, but the results are not going to be pretty.

If all the data is relational, and you're trying to enforce some sort of hierarchy on it, whether you're using an ORM or not is irrelevant, you've already lost the aesthetics war.
A great an opinion, which I once held. But when I looked deeply I only saw benefits.

I see tailwind as a damn cheat (a good thing), a hyper productivity tool throwing away all the what we learned as 'correct', and just get things done with escape hatches to fallback.

- Rapid prototyping with tailwiwnd

- Making component frameworks like bootstap? Just use tailwind sass with helpers. You can use a sass approach with including the helpers so you dont polute your DOM.

- it is easy to remember and guess which increases velocity. p-1/2 etc.. m-1 p-2 etc etc. Conventions make sense!

- Bloat can be solved with purge

- Refactoring easy easy if you abstract it away in sass so you can make global style changes.

- Protyping is easy, and you can then move it towards a component framework once you've done wiggling around and changing your stuff.

- I find css in components hard and painful personally also makes doing broad style refactors a bit more difficult.

- I also use css for email and other simple landing pages that dont require html components or react/webcomponents or whatever.

I find this a great addition to my life. Its a darn sharp knife, up to you what you do with it.