I’ve seen large Ruby projects with hunders of developers working on it for >10 years with almost 100% sorbet coverage. It’s just that in Ruby you have to pay (ie spend extra time) for decent degree of type safety.

I was always wondering if there’s some sort of limitation in science. Just like in some games you can’t fly according to the rules (science), so there’s just no way to do that without cheating. What if e.g. in 5k years we will reach the limit? Basically like after playing a couple of months in minecraft the only thing you can do is to expand

You can specify `minimum` and `maximum` property for these fields. So this schema

  {
    "$id": "https://example.com/test.schema.json",
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "title": "Person",
    "type": "object",
    "properties": {
      "hp": {
        "type": "integer",
        "description": "HP",
        "minimum": 1,
        "maximum": 15
      }
    }
  }

is converted to this BNF-like representation:

  hp ::= ([1-9] | "1" [0-5]) space
  hp-kv ::= "\"hp\"" space ":" space hp
  root ::= "{" space  (hp-kv )? "}" space
  space ::= | " " | "\n"{1,2} [ \t]{0,20}

For anyone curious here is an interactive write up about this http://michaelgiba.com/grammar-based/index.html

I’m not a parent, so it might be I completely do not understands some important aspects of this due to lack of expirience, but I hope I’ll be more smart than my parents. It was quite easy to google things my parents were silent about, but I still remeber that feeling of guiltiness. It affected me much more than knowing what the bdsm is

I’m sorry for an off-topic, are there any non-determenistic compilers you can name? I’d been wondering for a while if they actually exist

Accidental non-deterministic compilers are fairly easy if you use sort algorithms and containers that aren't "stable". You then can get situations where OS page allocation and things like different filenames give different output. This is why "deterministic build" wasn't just the default.

Actual randomness is used in FPGA and ASIC compilers which use simulated annealing for layout. Sometimes the tools let you set the seed.

Even if that’s true, it still doesn’t mean vibe coding is safe. :P

That is not a point a company selling vibe coding products is likely to emphasize in their marketing.

One thing people usually do is

D = Data.define do E = new end

which is wrong since ’E‘ escapes (it becomes ´Object::E´)

also, I agree that its kinda weird to use Ractor API but for us (service object gem) it was the best way to check if an argument is immutable (via Ractor.shareable?)

Now, imagine this situation taken to the extreme: searching for a job with relocation opportunities while residing in a country that many avoid for ethical reasons. :(

One of the key outcomes of my master's thesis was the development of an extendable solution for Code Clone Detection (CCD), primarily focused on code and tested with undergraduates at my university [1]. Although I didn't have time to complete the adapter for JPlag, I believe it would be highly beneficial.

Interestingly, whenever I discussed my thesis, the first reaction from others often revolved around moral concerns.

[1] https://github.com/studyfair/studyfair

This looks cool, but for me one of the big wins with JPlag is that I just download and run a single JAR file.