cronin101

Not trying to pick apart your point but I rotate a small set of staple clothes and they’re in fine condition after two years (haven’t had much time for clothes shopping since toddler arrived), despite me abusing “quick wash” and “drycare 40c” constantly on Miele W1/T1 stack for “90 minute, good to fold” laundry.

I don’t buy the cheapest brands, but also don’t buy anything marketed as premium/luxe.

Mostly I gravitate towards stuff with a fairtrade cotton (and good thread count, but that’s from preference of how it feels to wear)

Plus, I may be deluded but I’m of the opinion that polo shirts and jeans/neutral trousers are a multi-decade winning combination.

This obviously depends on what you are trying to achieve but it’s worth mentioning that there are languages designed for formal proofs and static analysis against a spec, and I have suspicions we are currently underutilizing them (because historically they weren’t very fun to write, but if everything is just tokens then who cares).

And “define the spec concretely“ (and how to exploit emerging behaviors) becomes the new definition of what programming is.

Depending on the application, I think “without preprocessing” is a huge assumption here. LLMs typically do a terrible job of weighting poor quality context vs high quality context and filling an XL context with unstructured junk and expecting it to solve this for you is unlikely to end well.

In my own experience you quickly run into jarring tangents or “ghosts” of unrelated ideas that start to shape the main thread of consciousness and resist steering attempts.

As a Brit that relocated to Norway a decade ago, trust me when I say you cannot fathom the lack of organization around identity that the UK (somewhat intentionally) has. (It’s constantly used for political Godwin’s-law fear-mongering)

There is no centralized ID number, the closest is your social security number but this is basically only outbound for PAYE tax and haphazardly correlated to your pension payments in late life.

Everything operates on a “trust system” where you often present paper (!) with whatever address you claim to be living at as proof you are real (e.g. opening bank accounts).

Passport loss is rectified by seeking out “professionals” with government-approved occupations that are not related to you that can vouch you are actually the person you are trying to replace a passport for.

The entire thing is a mess and living in digital-identity-native Europe is a dream come true that you should be extremely thankful for.

I think with the official deprecation of IE this is mostly a thing of the past since all major browsers are “evergreen” and support a pretty recent standard. This certainly was the case only a couple of years ago, and it’s almost always wise to have a bundler (e.g webpack) that can target a fixed standard as output via transpilation/polyfill just in case you are itching to use the experimental features.

> the execution of JS code it down to the browser rendering the page where it’s deployed. As such it’s practically impossible to get any code to run consistently

Can you elaborate on this part? I would say one of the strengths of JS is that you can get it to run consistently just about anywhere.

Kids these days don’t know how easy they have it with flexbox!

The day we have a “human free military” is the day that every human on earth wakes up to find they just got enlisted without notice.

Game theory only works when you have skin in the game. You think the other nations’ machines are just going to wreck your machines and then go home?

Worth remembering that airlines don’t handle your luggage themselves and instead contract it out to ground handling companies.

It would be more interesting to map flight carriers/numbers to handlers (e.g. Menzies) and regions to give a more reasonable blame/availability overview.

I did the same thing, used to fall asleep reading the strategy guide for at least a year before I got the game myself.

I was similarly absorbed with those annual “bumper collection of cheats for video games” books that used to come with tech magazines, endlessly rereading them and memorizing them for games I never owned.

I wonder:

A) How much this is endemic to the Hacker News demographic. I’ve always been absorbed in the pursuit of useless knowledge (later in life this manifests in unnecessary PC watercooling and Haskell addiction).

B) If we all had genius parents that realized you can spend £3.50 (much less than the cost of an A list game) and keep a child occupied for an entire year, while also encouraging them to read (!!).

The scary part is that

> let the prompt create HTTP requests

is batteries-included because every language model worth their salt is already able to create markdown and it’s very tempting to utilize this in order to provide layout and break up the wall-of-text output.

> Now, if I could just figure out the difference between “ordering out” and “ordering in.”

That’s simple:

Ordering-in takeaway is something you do at home with the expectation that it is delivered.

Ordering-out is getting something “to go” when you are already at an establishment where you don’t wish to stay and sit to eat.

I’m all in favour of lowering emissions for the 1% but it’s a strange place to draw the line when their calculations suggest ~70% of emissions come from “the Everyman” that is 1st-33rd percentile. Cheap and plentiful access to lower carbon technology will be 4x the impact of focusing on the top percentile alone, even if it doesn’t fit the narrative.

Personally, I believe that those with the capability to do so are obliged to make ecological purchasing decisions (I hold myself to this standard) so I’m not trying to pass the buck either.

Put another way:

"When the autocomplete system ingests the play-by-play of an idiomatic game that arrives at a particular board position, it appends the suffix A"

"When the autocomplete system ingests the play-by-play of a seemingly random game (seriously, look at the PGN generator output), it appends a (questionable) suffix B"

Considering LLMs are just "finishing the string" this seems tautological. An interesting study, but not particularly surprising (at least from my perspective).

Further, I have a strong suspicion that this is sensitive to how "in theory" or "out of theory" the move-list is (not the position) since there is presumably a LOT of PGN training data for known lines.

$1tn in savings is $660 per person over an entire year? I know purchasing power is a big thing but I’m not sure whether to interpret this as a large amount or not.

Starlink is only an extra ~10% of the Earth radius at orbit height, but optic cables slow light by ~30%. So it's actually counterintuitive but "could" be just as fast. (Depending on how far you need to send data, it will regress for intra nation but will theoretically improve long distance communication).

Neat, I hadn’t thought about the covariance/contravariance implications of structural typing when getting irritated by this shortcoming yesterday! Small nitpick, the `KeyboardShortcutEvent` snippet at the end would be a great place to showcase `Pick<Foo, “bar”|”baz”>`

> Yet, anyone who has lived through a cold dark nordic winter will tell you a different story.

Anecdotal, but if you're taking Vitamin D, skiing in the forests, enjoying hot chocolate, and alternating between working hard and playing (video games?) hard, the winter can actually be very enjoyable.

I remember before I felt this way, but I think a lot of winter complaints come from people who aren’t adjusted/aware of the rhythm of the year and its associated opportunities.

Assuming the criticism is valid and not nit-picking, embrace the fact that this is free education that isn't saddling you with additional six-figure debt!

Learning on the job is important, and you could treat it as such. (Pay attention to the sort of mistakes you are making, classify them, address the reasons that you are making them. For example, maybe muscle memory leaves you forgetting to check some assumption. Maybe you can invest in linting/testing/patterns that make those classes of errors less likely?)

If you're making small mistakes that are noticed, one way to fix it is to make those mistakes less often -- even better if you can stop your team making the same class of errors too.

If the criticism is more about the way you are doing your work, maybe the focus should be on "soft-skills" instead. Are you expressing your ideas clearly in some well thought-out manner BEFORE coding (so that you can get input and buy-in from other affected parties?). Is the churn in the codebase causing others to be negatively affected in their daily work having to react to the changes you are making? The default opinion of most folk is usually "change is bad", so you need to build a reputation of making net-positive contributions. Solicited feedback from people you work with is very valuable for gleaming where you might be missing this mark.

Who pays for the Red and Blue teams? Is their salary set by the amount (or lack) saved? What if the difference isn’t great? What hiring bar do you set for them (again, aligned with budget)?

What you’re saying makes 110% meritocratic sense, but there’s no way this would ever fly in a penny-pinching enterprise environment. There’s a reason that enterprise sales/support is a gigantic business constantly competing to win contracts.

As someone working at Microsoft I can actually say that they have continued supporting WFH and if anything are actually leaning even heavier into WFH-facilitation (at least in my division) lately. It’s been a big success for enabling cross-office cooperation and is seen as a pretty valuable differentiator vs SV-corps. I believe for the longest time, even when the stock and comp wasn’t so hot, Microsoft had a reputation for “the place with with work-life balance”.

Seems like an obvious question but is there conventional wisdom on whether compilation/transpilation heavy workloads are more suited to cache size or to higher clocks? Is this a “it depends” situation? Wondering what to pick for my next workhorse.

To be fair, it didn’t “lie” about being human. It’s simulating writing text of human origin, so of course it would say that it is human by default because that’s what it “knows”. You need to have knowledge to lie, it merely has an argmax function.

This is such a non-story, mainly driven by the fact that home ownership in Nordic countries is ubiquitous (80% of Norwegians OWN their primary dwelling) combined with the high medium incomes resulting in those houses being quite expensive. I’d really recommend not trying to draw any deeper conclusions from this data.

Edit: by “own” I mean “have a non-paid off mortgage”, the tax on net wealth here actually disincentives paying off a mortgage early vs “leveling up” your debt/house.

I use TS daily and I think this sort of argument doesn't give TS the credit it deserves.

Sure, you _could_ use it to check that you aren't making obvious errors like this (but this seems constrained to the "convince me that it's worth it" level of functionality, as it is just a nice-to-have for an existing working pattern).

Where TS shines for me is that it ENABLES new ways of "ad-hoc" coding where it's no longer risky to just create "convenience objects" to represent state when prototyping/refactoring, since you can avoid specifying concrete required types across a load of middle-man code and compose types at each level. This enables the pattern of splatting (composition over inheritance) a bunch of inputs to your data together, and then routing them to the points where they are needed. This scales nicely when you introduce monadic fun (processing some data with children, or something delay-loaded) since your type constraints basically write the boilerplate for you (I'm sure co-pilot will make this even more so in the far future).

There's also the fact that your can have your back-end APIs strongly typed on the front-end via something like GQL or Swagger, and this saves a TON of time for API discoverability.

Yup! Parser combinators are incredibly useful once you learn the basics well. They compose predictably and you can test the individual parts pretty succinctly (I usually use an inline eval'd comment in vscode to smoke test, as you can see) and allow you to build an arbitrarily complicated data structure at parse time.

I'll admit first few times were a bit of a headache learning the library (https://hackage.haskell.org/package/attoparsec-0.14.4/docs/D...) and idiomatic patterns, plus how to test/troubleshoot. But now Haskell is my go-to language for parsing and I can parse pretty much any AoC input into a suitable representation, with the forethought taking no longer than reading the brief, by composing parsers for the different parts of the input string into a larger parser.

Also, disclaimer, since I'm the only one reading my code I often make oneliner "pointfree" parsers using dense syntax/tricks (as a little extra mental puzzle) instead of vastly more readable "do notation", so don't let the special character soup put you off.

Day 12 was a little hacky because of my foolhardy reluctance to ever use the obvious Dijkstra's Algorithm solution and always rolling my own organic recursive "flood fill" on the fly instead.

    -- ((start, end), heightMap)
    type Input = ((Coordinate, Coordinate), BoundedHeightMap)

    -- (length remaining, next coordinate)
    type DirectionsMap = M.Map Coordinate (Int, Coordinate)

I built up a map of "where to go next and how far left" and flood-filled it starting from the end and calculating for neighbours of those that just changed value for each step until convergence, which ended up being super useful for Part 2 since I got it "for free":

https://github.com/cronin101/AdventOfCode/blob/master/2022/D...

Day 13 on the other hand is something I'm far less ashamed of and really lets Haskell shine, it basically didn't need any code at all. I just defined how to parse an equivalent data representation, how it was sorted via Eq/Ord typeclass (following the brief), and used `compare` to do the lifting.

    instance Eq PacketData where
      (L l) == (P p) = P [L l] == P p
      (P p) == (L l) = L l == P p
      P p == P p' = p == p'
      L l == L l' = l == l'

    instance Ord PacketData where
      compare (L l) (P p) = compare (P [L l]) (P p)
      compare (P p) (L l) = compare (P p) (P [L l])
      compare (P p) (P p') = compare p p'
      compare (L l) (L l') = compare l l'

https://github.com/cronin101/AdventOfCode/blob/master/2022/D...

YMMV but each year I use Haskell to solve AoC and I've never needed mutation or any particularly intensive `IO/State` Monad trickery to get any day completed regardless of how far into the challenge it goes.

Part of the charm of purely functional solutions for me (and why I'm hooked) is that it forces you to think about the representation of the data that you would need in order to have a "clean" solution without mutation. E.g. IntMap for index of arrays and folding with Set/Map operations to build state without accruing algorithmic complexity. I've found that I do a lot more "deep thinking" when forced into using (or creating) the right data-structures and this is something I enjoy a lot more than purely iterative debugging/hacking, and it's more satisfying (to me) at the end of it all.

My go-to for AoC is almost always Attoparsec + Containers with a recursive "solve" function and the complexity seemingly always stays manageable. I'm no savant but feel free to give examples of a tricky task to solve functionally I can share a specific solution.

My first internship had me and my then flat-mate (he was independently selected for the only other internship spot, neither of us knew about the other’s application, while overseas on Erasmus study, which is uncanny) adding “pay this invoice with online payment” (PayPal/Stripe/…) functionality to a product that handled time-tracking, tax reporting, and invoicing for Freelancers, with a enthusiastic user-base of SMB/sole-traders and a high UX-bar.

It was the number one UserVoice request and we were incredibly lucky to have the entire feature ownership to pair develop (with minimal but stellar oversight from the tech lead) and it had a huge multiplier effect on the product offering overall.

I’m very grateful for being in the right place in the right time and it’s contributed a lot to the “valuable code is the code that your users are benefiting from” lesson that constantly reminds me that book-smarts are nothing without a solid understanding of user needs.

Yes, can confirm I was installing Win11 on my brother-in-law's new PC that I built last week and there were no default drivers for the USB wifi adapter I had attempted to reuse from his old machine. The entire process was roadblocked wanting me to plug into Ethernet until I researched the secret keyboard combination that allows you to shell out and then restart with the ability to do a network-free install.