ggorlen
arr.reduce((acc, el) => {
if (el % 2 === 0) {
acc.push(el * 2);
}
return acc;
}, []);
arr.filter(e => e % 2 === 0).map(e => e * 2)
const result = [];
for (const el of arr) {
if (el % 2 === 0) {
result.push(el * 2);
}
}
In cases when reduce is required because (for example) JS doesn't have a sum function, it should be kept simple. `arr.reduce((acc, el) => el + acc, 0)` is acceptable if lodash _.sum() is not available.
In cases when reduce is required because the higher-level operations like map/filter aren't flexible enough, decompose the reduction operation into simpler steps and use map/filter with multiple passes, or write a traditional for..of loop.
This principle also explains why enhanced/range/of loops are preferred over counter-based `for` loops, and counter-based loops over `while`. Technically all loops can be handled by `while`, but it's seldom needed because enhanced loops handle the common case with the cleanest syntax. Reduce/while/counter-based `for` loops are antipatterns where higher-level, less powerful abstractions exists.
https://magnet-caper.glitch.me/
https://generative-placeholders.glitch.me/
https://spurious-soup.glitch.me/
https://conways-webcam.glitch.me/
https://doodle-jump-html.glitch.me/
https://fragmatic-glsl.glitch.me/
Linters make this a non-issue, and most modern development environments support them.
https://eslint.org/docs/latest/rules/no-console
https://docs.astral.sh/ruff/rules/print/
In situations where for whatever reason it's infeasible to use a linter, a basic grep can surface prints in a codebase reliably enough.
My approach is a step or two more automated (optionally using a userscript and a backend) and runs in the console on the site under automation rather than cross-origin, as shown in OP.
In addition to being simple for one-off scripts and avoiding the learning curve of a Selenium, Playwright or Puppeteer, scraping in-browser avoids a good deal of potential bot detection issues, and is useful for constant polling a site to wait for something to happen (for example, a specific message or article to appear).
You can still use a backend and write to file, trigger an email or SMS, etc. Just have your userscript make requests to a server you're running.
[1]: https://en.wikipedia.org/wiki/Scratch_(programming_language)
The LLNL internship seemed too IT-oriented to interest me. Mission Bit involved teaching high school kids to code after school, which I did for over a year and received course credit at CCSF for.
So it's not that surprising to me that they went from ~2 companies to 0, even disregarding the major drop in attendance at CCSF since 2017 [1]. I didn't attend any other fairs so maybe I missed something, but I never got the impression that they were especially "bumping".
[1]: https://sfstandard.com/2022/01/27/by-the-numbers-sf-higher-e...
It was a good life experience even though I wound up sacrificing my 4.0 by a few grade points. In hindsight, had I realized how steep the curve would be for DC, I'd have pushed a bit harder to squeeze out a few more test cases, but I was pretty mentally defeated at the time and felt like I'd exhausted all of the ideas I had on the projects multiple times over.
I found DC more difficult than compilers by a wide margin because of the nondeterminism, debugging difficulty and trying to figure out what the test harness was even doing. Compilers involved writing more lines of code, but it was manageable, synchronous greenfield application design.
Two difficult classes I took together were Embedded Systems Optimization and Compilers, both taught by the same instructor and with similar concepts, so working on one helped solidify concepts in the other.
On the other hand, I took Distributed Computing during its first offering alongside Graduate Algorithms and was super overwhelmed.
OMSCS graduate. The program certainly ate up most of my free time for 2.5 years, but on the other hand, the whole degree was about $8k for me and required no thesis or capstone project--just grinding through 10 classes worth of assignments and exams. Also, it was 100% online, so that flexibility frees up time.
Theoretically, if you do 1-2 easy-ish classes per semester, you can minimize the free time impact. But I was less interested in the credential and more interested in the learning experience, so I took difficult classes and worked as a TA.
Caveat: I graduated in 2021 so things may have changed since then.
- https://en.wikipedia.org/wiki/Kodokushi, the Japanese phenomenon of people dying alone and remaining undiscovered for a long period of time
- https://en.wikipedia.org/wiki/Joyce_Vincent, a British woman who had been dead over two years before discovery
Many programmers I've encountered in early stage tech startups (and in general) are not craftspeople--they're scrambling to get a product to market as quickly as possible and quality and process are very much secondary. Many are working in unfamiliar languages by necessity, or are relatively new or even untrained as professional programmers. I mentor such folk regularly. (Actually, these untrained hackers are often "better" at programming in many respects than senior engineers with 10 years of experience, but that's another story).
If the company survives long enough, they might pay off the tech debt later. OP's team just got unlucky doing the same strategy many other startups are doing nowadays and are willing to admit it.
To be clear, I'm not excusing the mistake or endorsing the process they followed, only noting that their actions aren't out of the ordinary (other than admitting to the mistake) and empathy is due.
How do you suggest I warn others to avoid this site? I don't think it's suitable for HN in its current state.
https://pagespeed.web.dev/analysis/https-vickiboykis-com-202...
Other noteworthy Albini-engineered bands for me: Oxbow, Low, Whitehouse, Labradford, Burning Witch, Godspeed's U.X.O album. Peter Sotos' Buyer's Market is one of the most insane albums I've ever had the displeasure to listen to, and Albini apparently produced it, although I don't hear any obvious influence.
I consider Varamo (comedic) and Episode in the Life of a Landscape Painter (tragic) to be standouts among the half-dozen Aira books I've read in English. I imagine a good deal is lost in translation.
There's a certain absurd, freewheeling alchemy to his works, but as tends to be the case with improvisation, they're somewhat hit or miss and require a bit of indulgence on the part of the reader. Luckily, they're mostly novella-length and don't wear out their welcome, so I don't mind giving him my time.
According to the article, he writes in places like McDonald's, which is comical and unsurprising. Likewise that he's an admirer of Raymond Roussel.
I didn't expect that he'd be a Morton Feldman fan, though. His books aren't as methodical, claustrophobic and somber as Feldman's works, but maybe share a similar sense of reflectiveness and focus on small, ephemeral moments.
Following the docs, `./tsac c myfile.mp3 myfile.tsac` generates a tsac file that's unplayable with mpv. Trying ffmpeg to convert to mp3 didn't work: `ffmpeg -i myfile.tsac compressed.mp3` ("myfile.tsac: Invalid data found when processing input"). Using a wav input file has the same result.
I can use `./tsac d myfile.tsac output.wav` (I don't really want to decompress anything, but worth a try) but then after compressing `output.wav` with `ffmpeg -i output.wav output.mp3`, output.mp3 is the same size as if I hadn't used tsac (of course). If I use ffmpeg with a low bitrate like `-b:a 16k`, I get the usual low-quality gargle rather than the tsac output.
(Of course, those repos may have main pushed later as well, invalidating this comment too)
Nice of the author to share the code. Thanks!
Chrome makes it a bit more intuitive, since the tab is called Sources, then click into Page > top > ugly-face > src.
That said, I don't understand why the author didn't simply commit the source code into the GH repo, especially since it's fully retrievable anyway. Maybe there's some goal in doing that other than security by obscurity I'm missing, since they've followed the same pattern for multiple of their repos. It seems kind of anti-collaborative to me.
[1]: https://www.builder.io/blog/structured-clone#why-not-code-cl...
This feels like extreme overconfidence in the LLM, sort of how I felt the first time I used one.
How many times did they run the test suite? How thorough is the test suite? How much does accuracy matter here, anyway? (seems like it does matter or they wouldn't advertise 100% accuracy and point out edge cases)
In my experience, LLMs will hallucinate on not only the correctness and consistency of answers but also the format of their response, whether it be JSON or "Yes/No". If LLMs didn't hallucinate JSON, there'd be no need for posts like 'Show HN: LLMs can generate valid JSON 100% of the time' [1].
If this gave 100% correctness on all test cases always, I'd need to throw out everything I know about LLMs which says they're totally unfit for this sort of purpose, not only due to accuracy, but due to speed, cost, external API dependency, etc, mentioned in other comments.
Suggesting that problems with edge cases and text manipulation are good candidates for LLMs seems dangerous. Now your code is nondeterministic (even with temperature set to 0).
I don't know the full history and I discovered it in the early 2010s, but it's been around since at least 1996 if the page content is to be trusted. I use a script to scrape the site and filter by artists I care about.