TN1ck

Also put the latest dump of Wikipedia on your phone (Kiwix is great for this). The complete English one with images is about 100 GB.

Thank you, that's indeed super interesting for me (we use go as our backend language).

> Speaker pitches for using embedded in-proc DBs inside AWS Lambda functions. Not practical to install Oracle RDBMS in something that only runs for 100msec.

It's not only unpractical, but hard to get it done. Recently tried to run Postgres in an AWS Lambda to create an anonymized DB dump. It was so painful that I gave up and created an access restricted database to do the anonymization instead. An in-memory mode for Postgres that would be as easy to run as sqlite or duckdb would be so useful for things where one can not replace it with either of them (sql dumps, testing).

Are there actually some systematic approaches to handle these cases? Or are there some libraries making this easier? We have so many places where we keep track of the offset and spread it over the items afterwards to mitigate this. It’s annoying as it’s most often a two step process and e.g. becomes even more complex when you have constrains on the numbers like applying discounts.

David Blaine says he drank only distilled water for 44 days [1], if that's true, it should be pretty safe to drink.

[1] https://www.happyscribe.com/public/the-joe-rogan-experience/...

Tens of hours? I wasn't aware that newborns are allowed to drive :D. Jokes aside, if you want to compare the training time, you should also include the time it takes us to learn our surroundings and navigate the world.

Had to laugh when I clicked on LiteFS and saw:

> LiteFS is currently in beta and is not recommended for production use yet.

Kind of JS dev in a nutshell, always bleeding edge.

What are the advancements since Clojure brought them to a mainstream language? More data structures got functional counterparts or better optimizations for “solved” ones like lists?

It definitely helps, a simple position change of the foot can make a total difference. But this is only one part, skateboarding is so much muscle memory, even if you know how to do it, you need to try it hundred of times to get your body to actually do it.

First person that I read about also having a problem with coffee and even with decaf. For me it started inducing anxiety like effects and gives me insomnia now if I accidentally eat a tiramisu or something containing a bit of it. Haven’t found anything that one can get an acquired caffeine sensitivity, but I guess there is not much research. I didn’t have an episode, but it did start during some more mentally challenging times.

As someone not having dwelt in the automobile industry, I found this quote interesting:

> The idea is still right, but of course, as you have seen, we've gone through the storming phase, a norming phase, now you know, having to deliver in the performing phase, but it's what you would expect

I can guess what these phases are, but is that a common workflow in the industry? I never heard anyone to refer to these cycles in software development. For me it just sounded like a poor attempt to explain the delays with some buzzwords.

I used sqlc[1] for golang, while it’s very cool and keeps things simple, at the end I switched to gorm as I needed hooks and dynamic queries where annoying to write. I could have build these things myself on top, but that would have been a homegrown orm in the end. But as every orm, gorm also has its problems, pick you poison.

[1] https://sqlc.dev/

> poor developers tend to try to make up for their perceived inadequacies by trying to look more professional in other ways (like behaving "professionally", dressing better, using marketingspeak on meetings, etc.)

I would actually look more into their "professional" behavior purely from a code viewpoint. As an example, I once had a coding interview submission that I was looking through and at first sight it seemed everything is there, tests, code comments, framework patters. My first thought was "Oh nice, they really are thorough". But looking deeper at it, these things hid the actual problems. E.g. The function interfaces were poor and mixed side effects when not necessary, tests tested _something_, but not what was important. And the algorithmic challenge wasn't even really attempted. This made me acutely aware of how easy this person could have passed a less technical interviewer, as everything looked professional. The effects are worse that someone whose obviously a junior or poor coder, their code looks off at first sight.

Partly, but it especially means things like Phoenix LiveView[0] or htmx [1]. With these you can create SPA like experiences by sending partial html updates from the server and applying them by some light JS to the UI (which you don't have to write yourself).

[0] https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html [1] https://htmx.org/

I thought I added numpad support, will have another look. I’ll add a setting to disable the highlights next week, thanks!

Yeah they conflict, haven’t really worked too much on how to resolve this. I mostly did the auto generated notes as I found them cool, how did you expect them to work? Currently they are live updating, but I guess a one of action might more sense?

Shameless plug: I built an open source, completely free, no ads/tracking whatsoever sudoku with a lot of bells of whistles. It’s only web based, so no native apps. Find it here: https://sudoku.tn1ck.com/

Source is at https://github.com/TN1ck/super-sudoku if anyone is interested

Modern dishwashers should be able to clean basically anything, most often when they don’t perform well, something got stuck in the water dispensers and there is just not enough water reaching the dishes (this will rarely create an error code). At least that’s my experience and I abuse those machines quite a bit in terms of what I put in there.

As far as I understand it, Peru already had a lot of highly cultivated potato crops. They have over 4000 different kinds and had sophisticated methods for preservation[0].

[0] https://en.wikipedia.org/wiki/Chu%C3%B1o

Yes, e.g. Vite uses Rollup for production builds. Vite uses esbuild for development with plans to make it usable for production builds.

Definitely one of the best apples for baking as it's very acidic. I'm always disappointed when I eat an apple pie that lacks in acidity, actually surprised by this list as it includes mostly very sweet apples which result in a non surprising low rating.

One can always add some lemon juice if one is forced to bake an apple pie with substandard apples at hand, works quite well.

The author of this article also wrote the for me mind blowing things like MathBox2 [0], the Pixel Factory [1] and many more. The often mentioned clone of React in the article, described in "The GPU Banana Stand" [2] is something that wasn't heavily discussed here as I think the concepts are just very advanced. I mention this as I believe this is what the author is concerned about and what some might haven't experienced. Using React for "advanced" things were it just doesn't cut it and one has to go back to manual DOM manipulation, or having to dig very deep to understand how one can build UIs were the elements update 60 times per second. React works great for things were this is not a concern, but if the standard has these innate restrictions, what applications will the future hold if all people know is React?

Though not a fan of some rants and the bashing on Zoomers, give them a chance to build the next iteration of the common tools, the oldest Zoomer is 25 at the moment.

[0]: http://acko.net/files/pres/siggraph-2014-bof/online.html

[1]: https://acko.net/files/gltalks/pixelfactory/online.html#17

[2]: https://acko.net/blog/the-gpu-banana-stand/

Very cool! I actually went onto the same journey 5 years ago - build a solver and sudoku generator (using the same paper) and finally a web interface. In the last week I finally got the motivation wrapping it up. I planned to release it this week, but as your post is so similar, it motivated me to make it already public as I think you'll like my web interface (if you get bored of using pen & paper), it's decently polished. You might find it interesting to read through my generation code [0], it's a slightly different approach, but also yields unique Sudokus of a certain difficulty.

[0] https://github.com/TN1ck/super-sudoku/blob/master/src/engine...

App: https://sudoku.tn1ck.com/ Repo: https://github.com/TN1ck/super-sudoku

Can you reference that? As a german I can see how "Uniklo" can mean that, but never heard that and I would rather assume it's a university toilet if someone would use it. From searching I can't find anything related to the term, i.e. duden.de doesn't know it.

I worked in a lab four years ago, where Kai (the designer of MetaTools) was an investor, but it didn't work out as although the tech was impressive and cool, it lacked the other components that are needed for a startup. They are still operating and building stuff in Edinburgh [0]. Sadly, they didn't release anything yet.

[0] https://www.kpv-lab.co.uk/

For a project that was basically an after effect like application I needed a history, but also very fast updates, settled with mobx-state-tree which gave me a way to preserve history. Worked great for that application, no regrets.

So there are some solutions available if normal mobx is not enough.

It seems they have a lot of problems recently and we are moving away as it’s just awkward to have so much downtime for a static site.

> I've never encountered a situation where the lack of typing bit me in the ass

Quite the claim! For me the moment I never want to look back to is to refactor a substantial part of the architecture of a JS app with more than 20k lines of code (And I did write most of it myself). If you don't do large scale refactorings or work mostly on smaller apps, then indeed, types won't be much of an issue.

But you should become aware about how often you see "undefined is not an object" and similar, that's a type error that is almost gone when using TypeScript.

You mean Vuze (back then it was called Azureus).

https://en.m.wikipedia.org/wiki/Vuze

I did the exact opposite move - moving away from sqlc to gorm. Sqlc is great and fast and it was a joy to use, but I needed the ability to track changes to database models. So either I would build my own abstraction on top of sqlc or work with database triggers. Gorm provided an easy way to hook into all of that as well as making several update queries easier. I still think that sqlc should be the first choice when you don’t need more complex features, but gorm does provide a lot of goodies.