Christ. Imagine if bridges, skyscrapers, dams, cars, airplanes were designed and built like that.

I vibeslopped thousands of pages of blueprints, nobody reviewed them, but another team of digital monkeys with the intellect of an ant have already built the bridge, and it seems to not have collapsed yet, so we're already directing traffic there.

I can't imagine actual engineers feeling anything but deepest contempt for this industry.

"Actual engineers" don't really care about software engineering, much less a strong emotion at all like the "deepest contempt" and many of them already vibe code today for their work anyway.

Oh no, we do, because the software world has been abusing what engineering means for decades, in order to inflate job titles. Most people are programmers, not software engineers, and that's OK.

What we do is absolutely engineering, there’s just a lot less credentialing upfront and rigor before something is released, because usually people’s lives do not depend on it and it’s easy to release updates.

But it is indeed engineering, and that’s OK.

The credentials and rigor are what Professional Engineering is supposed to include. The credentials help give bite to Ethics Boards and other tools used to keep the entire profession honest and safe. The rigor is supposed to include things like making sure that you are solving the right problems.

Many people's lives do depend on software today. Insurance software dictates who gets treatment and who doesn't; that's real lives at stake. Finance software controls access to things like food and shelter; that's real lives at stake. Firmware in prosthetics and diabetic injectors and so on and so forth. Software runs the world, we pat ourselves on the back saying, but forget the world is full of real lives.

Doing engineering with processes that are suboptimal with respect to a subset of the goals of engineering doesn’t somehow make it not engineering.

Sure, I think many of us are doing the best engineering work that we can given the industry situation. I've also seen so many of my peers, some of our brightest minds, waste their careers on stuff that a proper Ethics Board might stop or at least ameliorate. I can work to be the best engineer I can be and still wish we were an industry that actually respected engineering, not just used the title like a party favor that has no inherent meaning.

Why is it engineering what makes it engineering

We use science and technology to design, build, and maintain complex systems that solve real-world problems.

Do you have some other definition of engineering that excludes SWE?

That’s the thing we don’t need to invent a vague definition to attempt to cast a wide net

Here is the definition https://dictionary.cambridge.org/dictionary/english/engineer...

Maybe you're an outlier seeing as you're even on this forum. Most other non software engineers I know do not give a single thought about "title inflation," it does not even register in their minds as a topic to think about.

My resume includes a bunch of time at a primarily Civil Engineering firm and one of the things I took away from that was also some respect for this "title inflation" issue. That company would not allow any "Engineer" in a title that didn't involve someone without up-to-date PE credentials. Technically my title the whole time there was "Senior Software Developer". I still feel guilty switching my resume back to "Senior Software Engineer" to not have to explain that "gap" to software interviewer who somehow think "Developer" is a less important title than "Engineer" and don't understand title inflation in our industry.

(At one point I even debated the value of getting PE credentials at my age for extra leverage in that company.)

as long as they stay away from boeing or anything that flies...

They landed 802,000 lines of code in a single commit: https://github.com/vercel-labs/scriptc/commit/23d5918a5381e0...

This is not the Vercel ad they think it is.

That makes sense. It also seems like this uses a lot more dependencies and tiers of compilation whereas Porforr is trying to do everything from scratch.

900k lines of code plus tons of deps for a compiler? Does that really make sense to you?

It's coming from Vercel, what do you expect?

I don't actually see any dependencies other than node and typescript (and the optional quickjs package) (maybe they inlined dependencies? But the package.json files don't indicate any npm dependencies)

That explains why:

- the architecture is idiotic.

- they have zero credible perf numbers.

I plan to benchmark it using generally accepted methods.

Porffor makes careful trade offs that make sense and is benchmarked in a way that I can believe.

(Source: I make dynamic languages fast for a living)

Putting aside the whole “team of professionals putting out a product vs solo dev fine tuning their opus” of it all:

Can you clarify what about the architecture is ‘idiotic’? Not trying to catch you or demand a defense, just looking for a vague description. I don’t even know how to start examining the architecture of something like this.

Yeah

- using quickjs at all in a thing that needs perf. Quickjs is hilariously slow. Midwits use it because it has “quick” in the name.

- using floats for numbers and deferring int optimizations for later. Inferring ints is like half the problem of fast JS.

- rejecting inadequately annotated or too dynamic code without a whole heck of a lot of self-reflection about how unlikely that is to work out.

The observation that languages that are even slightly dynamic need dynamic JIT opts is very old; folks figured that out in the 80s.

This project reeks of weapons grade AI psychosis

As far as I can tell they pull in QuickJS (actually quickjs-ng) only in the case where the program has untyped dependencies that still need to be run by an interpreter - and they chose that library because it's pretty small (620KB). Did I miss something, are they using it outside of that purpose?

They will have untyped dependencies. That’s how the TS/JS ecosystem works.

Note that “untyped dependency” means any code that says `any`.

They won't have untyped dependencies for situations where someone used Scriptc as a way to build a fast binary executable for some custom-written TypeScript, which was the first use-case that came to mind for me.

Being able to build small, fast binaries without writing them in C or Rust - if you're already fluent in TypeScript - seems like a valuable capability.

Yes, being able to build small and fast binaries in TS would be a valuable capability, which is why basically all of us who work in this space have thought of this idea and rejected it after going deep on it. This isn’t a new idea.

CanadaHonk has gotten further than the rest of us. It’s surprising and impressive.

You’re only replying to the quickjs issue I raised, but it’s not the only issue. Their approach to numbers is broken. Their approach to measurement is broken. The quickjs thing raises another red flag: it suggests to me that they are using reference counting, not GC. That’s guaranteed to make them too slow to be useful. (If they weren’t using RC, then they’d have a hard time on the boundary to quickjs.)

As to the `any` issue, let me explain it in a way you’ll appreciate. I asked Claude how likely it is that TS code uses any, and it found:

- 79.5% of TS repos use any explicitly. So, about 4/5 chance that newly written dep-free TS code will use it.

- the explicit any type is about as common as Boolean and void.

- a third of inferred types are any. That’s huge.

So, if you don’t believe me, then at least believe Claude: any is a super common type, so they will be falling off into quickjs a lot.

Oh, and in case it isn’t clear, quickjs-ng is no better than quickjs. They’re the same thing for the purpose of perf

The QuickJS thing doesn't seem like a big deal to me, provided the documentation makes it clear that code will run slower if you use Any.

If I was using this project for something I'd expect to write custom TypeScript for it.

The floats rather than integers thing does look bad though. I tried compiling their fibonacci example to C (--backend c) and got this:

  static double sc_f_fib(double sc_l_n_0) { /* /private/tmp/fib.ts:1 */
    double sc_t0 = sc_l_n_0;
    double sc_t1 = 2.0;
    bool sc_t2 = sc_t0 < sc_t1;
    double sc_t3;
    if (sc_t2) {
      double sc_t4 = sc_l_n_0;
      sc_t3 = sc_t4;
    } else {
      double sc_t5 = sc_l_n_0;
      double sc_t6 = 1.0;
      double sc_t7 = sc_t5 - sc_t6;
      double sc_t8 = sc_f_fib(sc_t7);
      double sc_t9 = sc_l_n_0;
      double sc_t10 = 2.0;
      double sc_t11 = sc_t9 - sc_t10;
      double sc_t12 = sc_f_fib(sc_t11);
      double sc_t13 = sc_t8 + sc_t12;
      sc_t3 = sc_t13;
    }
    return sc_t3; /* /private/tmp/fib.ts:2 */
  }

If you’re writing Typescript with zero dependencies and trying to target native I feel like it makes more sense to write it in a different language like Rust or Go. The main reason for this I think is getting cheap perf wins by running existing code natively.

For some new custom small thing you'd be better off using not this though, right?

Personally i can kind of see a use case here. I've shipped some simple server side packages as a "compiled" Node single executable written in TS, but you're stuck with the big overhead of Node.

I've just been teaching myself Go, also a single binary but without the overhead. But in Go i miss the expressiveness of the TS type system sometimes.

> if you don’t believe me, then at least believe Claude

I had to do a triple take on this.

I think more human effort is going into defending this project then what was put into the project itself haha.

There is always AssemblyScript

Devil's advocate - this is for the backend. You get to control your dependencies there, and I'd say Vercel controls its own stack, so they can replace deps as they go by submitting patches/slopforking projects to remove incompatible features.

> "As far as I can tell they..."

This phrase I think highlights the fundamental issue for a lot of folks that would otherwise consider adopting a project like this written by humans.

> deferring int optimizations for later

This part made me laugh out loud

"This project reeks of weapons grade AI psychosis" - fantastic quote: I will shamelessly steal & use. Apologies to pizlonator

> using floats for numbers and deferring int optimizations for later. Inferring ints is like half the problem of fast JS.

For a project like this, isn't it worth introducing a TS type for Ints? Since they are trying to leverage TypeScript anyway...

So you don't actually have real criticisms of the architecture at all...?

Just randomly:

1. TS only has a "number" type. But what type of number is it? This is doable safely via keywords (or known markers), or sometimes via analysis, but I couldn't find it in the README.

2. A compiler that works only on macOS?