cyco130

Absolutely. When we started growing (I was employee #3, we were about 20 people when I left), we didn't use our own product for our own needs. It wasn't designed for a tiny startup, it would be like building a sand castle with a bulldozer.

But we started as a "boutique" company that implemented everything requested by our then small number of clients (mainly out of desperation, we were self-funded and we didn't have much leeway, we needed those clients). It was as flexible as it gets before the LLM times.

But after a while, you start noticing patterns, an understanding of what works and what doesn't in a given context. Our later customers rarely requested a feature that we didn't already have or we didn't have a better alternative of. It's not like we had a one-size-fits-all solution that we forced on everyone. We offered a few alternative ways of working that fit different contexts (hiring an airline pilot is a very different context than hiring a flight attendant). And in time, this know-how started to become our most important value proposition.

At some point we even started joking about leaving the software business and offering recruitment consulting services instead.

For six years I worked in a SaaS startup that built an applicant tracking system (a tool to manage recruitment efforts in big/mid-sized companies) tailored for the local market of the country we lived in. My experience tells me that our main value was in forcing them to rethink their recruitment processes, not adapting to their existing ones that were usually all over the place.

As much as I want to believe the opposite to be true as a “power user”, good tools often force you to adopt better practices, not the other way around.

It requires parentheses `(3).myMethod()` but you can by monkey patching the Number prototype. Very bad idea, but you absolutely can.

I write some of my thoughts on this sone years ago. The library described at the end is now fairly out of date but the ideas and suggestions are still good, I think.

https://dev.to/cyco130/how-to-get-client-side-navigation-rig...

Fair enough. I fully agree.

Deaf homo sapiens sapienses do have perfectly good language skills.

It also had the best “swipe” text typing mode for Turkish. iPhone got it very recently and it’s close to useless and Android one was meh last I checked.

Another way to induce memory corruption glitches on old computers was to quickly turn off and on again. I never managed to get anything useful like your unlimited lives hack out of it but I did see lots of interesting graphical glitches on my Atari 800XL back in the day.

I believe at least the Vitest project considered using node:module hooks for live reloading but rejected it in the past. The reason given to me was that, there is no way to garbage-collect a real EcmaScript module since they're always reachable by the module ID string as per the specification.

This kind of leak was deemed acceptable in a browser tab (which we tend to close or reload often) but unacceptable for a long-running server process.

Pseudo-modules based on node:vm, on the other hand, will be collected normally when they become unreachable.

The green proposal was the one that got picked up to become Ada by the way. Red was the runner-up.

Don't know about the whole Europe (or EU) but I strongly suspect it is indeed (almost) everywhere. I'm Turkish and Turkey has it too. And yes, my mother uses it, and my grandparents used it when they were alive. You can't do anything government-related, open a bank account, or even visit a hospital without your government-issued ID card (which contains a chip). And a few decades ago, before the chips, there were other security measures tied to ID cards.

The reverse effect is also interesting: I think what women think men go for in a woman is very different from whan men actually prefer. Reminds me of Seinfeld's The Fix-Up episode: "Who cares about eyebrows"!

An old teacher's saying from Turkey (where grades were out of 10 back then): 10 is for god, 9 is for me, the best student gets an 8.

And now I’m proud because that’s pretty much the exact idea I tried to pitch at the great grandparent.

Gold mine! Didn't know about to concept, thanks.

I've long entertained the idea of a language feature that allows returning unknown sized objects by value. The calling convention would generate two function calls, one to go get the size which would then be passed to alloca to reserve space for the return value and a second call to get the actual result. Not sure of all the implications but I think it might be an idea worth pursuing to make things like variable length arrays and structs with flexible members near-first class constructs in the language. Pseudocode:

   function zero_filled_int_array(length: usize): int[length] {
      ...
   }

The int[length] bit determines the return value of the size call and the main body constitutes the part that actually fills in the value.

I’m Turkish as well (and over forty). It’s a joke, I have no data on its prevalence except anecdotal. It does seem much more common nowadays than when I was a kid though.

Reminds me of a dark joke I sometimes make: Why are there no Turkish people above forty with nut allergies? Because they all died in early childhood.

As others have pointed out, that's pretty much how things originally started. A more recent example I remember is the Action! programming language for Atari 8-bit computers[1], an Algol descendent for 6502 with static activation frames.

But I don't understand the appeal. Many algorithms and data structures are most naturally expressed with recursion. Not allowing it forces the programmer to create and maintain their own manual stack data structures which brings us to square one in terms of statically-guaranteed upper bound on memory usage since they can grow indefinitely. At best, stack overflow errors will be replaced by array out of bounds errors which is the exact same thing anyway. In fact, it will be even worse: Manual stack implementation will come with its own complexity and source of bugs.

[1] https://en.wikipedia.org/wiki/Action!_(programming_language)

That’s the tricky part. There’s no stack anymore. Activation records of functions are heap-allocated and can stick around as long as necessary.

Unfortunately Firefox is no real competition either. Most of their revenue comes from Google, ostensibly for making Google the default search engine but, in reality, probably to allow Google to avoid antitrust lawsuits by claiming they have a real competitor.

I'm building a web-based Atari 8-bit emulator [1]. I haven't pushed my current progress yet, the repo only contains the CPU emulator and a few utils which I wrote a few years ago. Lots of bugs and missing features but it can already run some of my favorite games, so I'm pretty happy and proud!

[1] https://sfotty.cyco130.com

Even 6502 from 1975 has it (and a few more like shift/rotate instructions).

LLVM now uses something they call the "Greedy Register Allocator". As far as I can tell, it's a variation on the linear allocator with some heuristics. Here's a presentation: https://www.youtube.com/watch?v=hf8kD-eAaxg

Not a rhetorical question: Could it be that part of the speed difference is due to the file system speed? I was shocked when I saw how much modern(ish) Windows file systems were slower than modern(ish) Linux ones.

I think it’s a seriously good idea. I believe they could create problems during the content scraping phase but considering that Internet Archive has most of the content already, I don’t see how they could legally prevent such a move if you’re careful with their trademarks and other intellectual properties like logos and look-and-feel.

It’s usually not dramatically simpler though. Many of them (C++, TypeScript, Rust…) end up growing into esoteric, “accidentally Turing-complete” monstrosities that are much harder to reason about than simple if statements and loops.

> zero so far this year

I saw what you did there.

It's a tradeoff. Advanced generic programming as implemented in many other languages requires you to learn a completely new language. That new language is better suited for some use cases. Functions that take types and return types, on the other hand, can be more intuitive in other cases.

For those non-native speakers confused by this usage of the word “rake” like me, it’s, apparently, the meaning under “Etymology 6” on Wiktionary: https://en.m.wiktionary.org/wiki/rake