bearforcenine

Our backend is primarily in Scala and has been for over a decade. My take is that Scala 2 -> 3 was a massive hit to the language's momentum. It came at a time when the language's popularity was waning and it had all the same challenges that other major language version changes tend to have. Migrating's been quite challenging. Tooling, which was already a challenge for the language, got worse because it was split between Scala 2 and 3.

The language was deliberate about providing backwards and forwards compatibility between 2 and 3, but they didn't have a good story for macros. Yes, macros were experimental, but the ecosystem relied on them very heavily. This meant that your 3rd party dependencies likely hadn't migrated to Scala 3. If they had, things got complicated because you had to deal with two macro systems.

After many years the tooling is finally catching up and many 3rd party dependencies are available in Scala 3. That said, it's taken years and years. I think during those years many companies migrated to other languages or put a moratorium on new projects in Scala.

Did MoonBit add support for some kind of shared memory concurrency like threads? I remember discovering the language, being very excited about it, and then learning it is single-threaded, which makes it a poor replacement for Rust IMHO.

Agreed. There was a period of time roughly 10-15 years ago where symbolic operators in Scala were very en vogue. That fell out of style in a big way and I haven't encountered symbol soup in a very long time.

Most of the conversations I have with folks about Scala issues these days center around implicits, tooling, and its decline/lack of popularity.

Not confident it's quite that straightforward. Here's a presentation from Meta showing a 6-12% increase in diff throughput for above-median users of agentic coding: https://www.youtube.com/watch?v=1OzxYK2-qsI

It's Jujutsu based, but I imagine East River Source Control https://ersc.io/ may be building a GitHub competitor.

From my perspective the two biggest challenges of the Scala 3 migration were macros and poor tooling support.

Macros were an experimental Scala 2 feature, but were used all over the Scala ecosystem. Because they were considered experimental a good migration story for them was never developed. That lack of support stopped migration efforts dead in their tracks at our company for a long while. It just wasn't worth contributing simultaneous support for Scala 3 and Scala 2 macros to every third party dependency who used Scala 2 macros. That said, we did it for some and lived on a fork for others.

IDE support for Scala 3 was really rough when it first released. We checked in on it with every IntelliJ release for roughly 3 years before we decided it was far enough along. Prior to that it was rough enough that we froze migration efforts in order to keep the tooling usable enough for engineers to be productive.

Compiler error messages improved significantly with Scala 3. IIRC there was a dedicated effort with Scala 3 to improve error messages and make them more actionable. Scala 2 error messages improved somewhat over time, but can still be obtuse.

Isn't the table sorted alphabetically?

Based on my reading of the table, the PurpleAir II sensors seemed to be the best of the sub $300 for PM1.0 (field R^2 of 0.96 to 0.98) and PM2.5 (field R^2 of 0.93 to 0.97). The PM10 readings were not as good (field R^2 of 0.66 to 0.70).

After skimming the rest of the table, it looks like the PurpleAir II sensors might have some of the best field R^2 for PM 2.5 and PM 1.0

PurpleAir also makes an indoor air quality sensor that measures particulate matter: https://www2.purpleair.com/products/purpleair-pa-i-indoor

Not sure how it compares with Awair or laseregg.

I have no affiliation with PurpleAir, but they are pretty popular in Utah.

One thing I'm not totally clear on after reading the article is which AWS account the AWS KMS resides. Is it Slack's AWS account or the customer's?

Similar experience with Dota 2 and ESL on Facebook. The experience was horrible. Viewership was bad. Doesn't seem like anyone was happy about it https://twitter.com/Slasher/status/1071863217243197440

If I recall correctly, people on Twitch streamed games from the Dota Majors/Minors and got more viewers than the Facebook stream. Then ESL started DMCA'ing streams https://www.reddit.com/r/DotA2/comments/7skt8e/did_mlpdota_j... Then Valve got involved and made a statement about the whole kerfuffle http://blog.dota2.com/2018/01/dotatv-streaming/

>I don't understand why they wouldn't do it, though. I see no plausible explanation.

Money seems like a good reason. If a tiny fraction of your sales and a large fraction of your bugs are from a particular subset of those users, you don't want those users. They are too expensive.

Several years ago, I ran into the exact same nausea with the Source engine as the GP, but when I increased the FOV the problem went away.

I've run into nausea with other games that have a narrow FOV. Increasing the FOV (when possible) usually fixes the problem.

As far as I understand, the late Total Biscuit was similar. He frequently advocated for FOV sliders in games. I greatly appreciate his help making FOV sliders more popular.

I imagine there are climates that are better for grass or certain species of grass that are very drought tolerant. However, in my experience, not watering a lawn will kill it. I have a few patches in my lawn that were killed this summer by lack of water due to a poorly designed sprinkler system.

If you only have 20% of your time available to write code, then I would much rather you do not review code in which the person who wrote it had 90% or more of their time to write code. The review will be less thorough, correct, and timely than if someone else who regularly spends more time in the code.

These 'junior engineer' tasks are attractive for a manager who still wants to be in the code. They are non-critical and small. Perfect for someone with an unpredictable schedule. However, they also provide an opportunity for the manager to have a better, but still imperfect sense of the codebase and technology.

This is exciting to hear. I look forward to hearing more.

I understand that both kube2iam and kiam exist and they're both fine. I am interested in Amazon/EKS directly supporting something. Hopefully we will see something soon via CRD or otherwise.

>we need to set up a way to manage AWS IAM credentials to Kubernetes pods... In a production system, this should be done using a tool such as kube2iam or kiam...

I am curious if AWS has any plans to build an IAM integration for K8s that provides IAM credentials/roles directly to pods. An integration through EKS or K8s directly would make interacting with AWS resources very easy.

Being able to authenticate to the K8s cluster using https://github.com/kubernetes-sigs/aws-iam-authenticator is nice, but it doesn't help give pods IAM roles.

Google did a bit of work on converting Closure annotated JavaScript to TypeScript. It's called Gents and it's part of the Clutz project https://github.com/angular/clutz/tree/master/src/main/java/c...

We used it at Lucid when we converted our codebase from Closure annotated JavaScript to TypeScript. https://www.lucidchart.com/techblog/2017/11/16/converting-60...

Google has support for using TypeScript in Closure annotated JavaScript via Clutz: https://github.com/angular/tsickle

It also has support converting TypeScript to Closure annotated JavaScript via tsickle: https://github.com/angular/clutz

Before we converted all of our codebase to TypeScript we used both Clutz and tsickle. It was complicated to setup, but it worked. Now we just use tsickle. It's great to get the optimization of the Closure Compiler while using TypeScript.

Lucidchart and Lucidpress are large projects that are almost entirely TypeScript on the frontend. The team really likes it. We use TypeScript and Angular that is compiled using Tsickle and the Google Closure Compiler.

It's not perfect, but we have found the types to be very nice when working on a large code base with lots of people. Dev development cycle remains quite fast.

Thirded. There are some exciting things happening in the Scala build tool space right now. We're migrating everything to Bazel right now, including our Scala code. Bazel + Scala is not amazing yet, but so far I have enjoyed it much more than sbt. It's also very nice to use the same build tool across all our languages.

Is it, though? There are so many other ways that someone might not be a good "fit." Maybe you found another, slightly better candidate who is willing to accept a lower offer. Maybe a manager or individual contributor feels that their position is threatened by the candidate. Maybe they don't attend weekly happy hour.

What do I do when I quit my current job, move across the country, and then get fired 30 days later? I would likely never accept an offer at a company that tells me up front there is a good chance I will be let go in 30 or 60 days.

It would be great if many of the games worked like that. Sadly, in my experience, you can report/block someone and then immediately be matched with them again. This is especially true in games like Heroes of the Storm which have smaller player bases.

Being able to block someone and not be matched with them again is also a great mechanism to dodge better players. If you have a hard time beating a particular player? Block/report them, avoid being matched with them, and have an easier time winning.

My biggest complaint with Hulu is the watermark/bug they add to everything. It is large, unsightly, and can be very bright compared to the actual content. I signed up for Hulu ad-free premium, but dropped it because of the bug.

Broadcast tv, satellite, and cable networks often have a bug show up when a show returns from commercial break. It is somewhat transparent with dulled colors, and often disappears after a short period of time.

Hulu's bug is large, less transparent, bright white, and sticks around for the entire show.

It was pretty bad when watching something with a dark scene - bam - blinding white watermark distracting from the actual content.

While you may be offended by it, this article didn't invent that ratio. It's been around for years, as far as I can tell. I'm not certain where it came from, but it's pretty normal to use grams per pound when discussing protein intake in the US.

Awesome. Thanks for that! I was initialy put off the by the several year old posts, but it looks like SAG has been updating them throughout the years. https://www.reddit.com/r/HandsOnComplexity/

I've been digging into growing some greens, peppers, or other vegetables for fun. Playing with lights, pumps, and controllers seems pretty fun.

As far as I know Farm.one is using some Fluence Bioengineering LEDs for grow lights: https://fluence.science/innovator-spotlight/farm-one/ However, in the article it looks like they might be using strips of COB leds? Anyone have any thoughts or resources for doing this sorts of stuff?

Finance at least has prep for interviewing for investment banking, trading, and consulting. When I was in undergrad it was common to have mock interviews and prep for commonly asked interview questions. Most people prepped on being able to walk you through basic financial statements, valuation, brain teasers, case interviews, and stuff like that.

I'll take your word for the other fields as I can't speak directly to interview vs exams there.