Hacker Newsnew | past | comments | ask | show | jobs | submit | Zariff's commentslogin

I always think of Andrew Ng's famous machine learning course whenever I hear someone say this phrase. He also used this phrase repeatedly in the videos.


Didn't he used to say "concretely" all the time as well?

That was such a cool course. It seems ancient now, but I remember enjoying it at the time.


Yes, he's the person I'll always associate with this phrase for exactly that reason!


I'm not familiar with WASM. Can someone explain why this is a good thing? How does this work with languages that do not have a garbage collector, like Rust?


The answer was kind of known before hand. It was to enable the use of GCed languages like Python on Ruby to create WASM applications. Meanwhile, non-GCed languages like Rust, C and C++ were supposed to continue to work as before on WASM without breaking compatibility. This is what they seem to have finally achieved. But I needed to make sure of it. So, here are the relevant points from the WASM GC proposal [1]:

  * Motivation
  - Efficient support for high-level languages
      - faster execution
      - smaller modules
      - the vast majority of modern languages need it

  * Approach
  - Pay as you go; in particular, no effect on code not using GC, no runtime type information unless requested
  - Don't introduce dependencies on GC for other features (e.g., using resources through tables)
[1] https://github.com/WebAssembly/spec/blob/wasm-3.0/proposals/...


Note that the high level language needs a sufficient abstraction in its own runtime to allow substituting the Wasm GC for the runtime’s own GC. Work has been done for Java and Kotlin, but Python, C#, Ruby, Go can’t yet use the Wasm GC.


Agreed. That's what I guessed too. WASM GC is probably a low level component which high level languages can wrap to get their native/idiomatic GC behavior.

> Work has been done for Java and Kotlin

I'm unaware of this development. What did they do? Did they create an interface to the GC specification in the draft proposal?


Well, for Java it's actually a separate compiler that targets Wasm and integrates with WasmGC: https://github.com/google/j2cl The Google Sheets team used it for their calc engine: https://v8.dev/blog/wasm-gc-porting

For Kotlin it's similar but the compiler backend is from Jetbrains themselves, targets Wasm and adapts the Kotlin runtime to use WasmGC: https://kotlinlang.org/docs/wasm-overview.html. https://seb.deleuze.fr/introducing-kotlin-wasm/ has some low level detail on how Kotlin works with WasmGC.

A bit more on Kotlin/Wasm here, seems like also Dart/Flutter uses WasmGC: https://developer.chrome.com/blog/wasmgc#kotlin_wasm

https://github.com/dotnet/runtime/issues/94420 has some notes on why C# can't use WasmGC (yet?).


Good info! Thanks!


to also consider this one https://github.com/6over3/zeroperl


Non-GCed languages will continue to manage memory themselves. Previously, GCed languages that wanted to run on WASM had to have an implementation of their runtime including GC compiled to WASM. The idea or hope here is that those languages can use the built-in GC instead and slim down the amount of WASM that needs to be delivered to run the application to only include a minimal runtime. The current scenario is closer to if a web app or node app built with JavaScript had to ship a significant portion of V8 with it to function.


This will probably benefit Java applets targeting Wasm the most considering the huge size of their JVM.


Would not be surprised to see the typeinfo needing shipped taking up more space than the internal GC implementation it replaced :)


Hopefully Go as well.


Here's a fun example of a language that takes advantage of this: https://spritely.institute/hoot/


I works very well, thank you for asking: https://rustwasm.github.io/book/


I'm not familiar with how journal submissions work, but don't you simply submit a pdf at the end? Does it matter what engine you used to render it?


You normally submit a LaTeX or Word document, and the publisher does the final typesetting. Even in computer science, where people often spend a lot of time tweaking the typesetting, the pdf generated by the authors is essentially a preview. There are often visible differences between it and the publisher's version.


Yeah this is one of the craziest things about the scientific publishing industry.

Journals justify their fees by claiming its for typesetting, but all they are really doing is adding extra work to nit pick bibliography formats and so on (see the comments in this article about sentence case). Nobody cares about that. I don't think anyone even reads "journals" any more (except maybe Nature/Science etc.). They mostly just read individual papers and then there's no consistency to maintain.

In a sane world journals would accept PDFs. They would check that the format roughly matches what they expect but not insist on doing the type setting themselves.

Oh well, maybe one day.


I would note arXiv requires the source as well, and having the source is what is enabling the HTML experiments they're doing.

On consistency, what the journals provide is some level of QA (how much is a function of field and journal, rather than the what is charges), and the template is the journal's brand, so both the authors and journals benefit from the style (I can tell the difference between the different (all similar quality) journals in my field at a glance by the style).

It's also worth noting that there's a whole much of metadata that needs to be collected (whether you agree with it or not, funders require it), so a PDF isn't going to cut it here either.


Citation and bibliography guidelines are by far the things that authors neglect the most, and they are absolutely essential to ensure quality.

Using PDF as an input format would make editing and typesetting practically impossible. Not that I haven't seen volumes where publishers did that but the results are abysmal and in my experience that only occurred with local "grey literature" like really crappy conference proceedings edited in an institute.


> Using PDF as an input format would make editing and typesetting practically impossible.

But they don't do any editing or typesetting. They say "use our template" and "the author's second initial needs to be italic in citations". That's my whole point.


> Journals justify their fees by claiming its for typesetting [..]

Because they used to actually be doing that. Historically, science journals were pay-to-play because the journal had to typeset your document and print it. But with the advent of computers, they had to pivot while still retaining their revenue streams.


Not only do you need to use LaTeX, but you need to use the journal's class file. Anything else will get rejected.


I don’t think I understand the author completely. First, she mentions that Podman is not a replacement for Docker but then mentions multiple reasons why Podman is better than Docker. I.e. why you should replace Docker with Podman.

What did the author mean by Podman is not a replacement of Docker?


She means that it's not a drop-in replacement that works exactly the same way.

It works differently, and (in her opinion) in some ways better.

But you will likely have to change your workflow to use it.


Neil deGrasse Tyson also mentioned this. User noufalibrahim already gave a good response to that. But if you're interested, Mohammed Hijab also replied to that claim in this video: https://www.youtube.com/watch?v=nfRnYNig9jU&t=36s&ab_channel...


So you prefer Python, I assume?


Depends on the problem to solve. For calculation-heavy tasks i prefer python. But these days many use R to create shiny-apps which should be done in javascript instead.


That's one way to look at it. The other perspective is that with shiny 'many' are able to create interactive apps to display and explore data which would have required 5x as much time to make with js +/- d3


Shiny does use javascript; are you against the wrap?


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: