benjaminjackman

There is a 60 second limit which seems to be the biggest difference.

> One downside to godot’s inheritance is everything is set up in code and decided at compile time instead?

That's not really the case because Godot can load scenes at runtime. The scene format itself (.tscn files) is text based[1] (which is also nice for version control) and could be edited by hand, then loaded into the game at runtime. Though since the Godot editor is open source and totally free it would probably be better just to ship that with the game. It's also really easy to extend so custom game centric plugins that modify the editor itself are also easy to write.

1: Here is a sample scene file, just to give a sense of the format:

    $ cat enemies/bandit/BanditSpread.tscn

    [gd_scene load_steps=2 format=2]

    [ext_resource path="res://enemies/bandit/BanditBase.tscn" type="PackedScene" id=1]

    [node name="BasicBandit" instance=ExtResource( 1 )]
    fire_period = 0.85

    [node name="VK-001" parent="Sprite" index="6"]
    visible = true

    [node name="LG-Anger" parent="Sprite" index="8"]
    modulate = Color( 1, 3.1875, 6, 1 )

    [node name="ProjectileWeapon" parent="Hardpoints" index="0"]
    projectile_spread_degrees = 60.0
    projectile_variance_degrees = 0.0
    num_projectiles_min = 6
    num_projectiles_max = 6

This looks pretty neat! I briefly looked for Immediate mode gui libraries for Java, just to experiment with. I see this has java bindings (though 3 years old). I had been planning to try out the jni wrapper for Dear Im GUI which I have used in C++ before.

Just wondering if anyone has used a decent pure jvm immediate mode gui library before or have suggestions on immediate mode libraries in general to try out?

For what I am thinking of trying it out with, my needs aren't too high so I might just write something simple with libGDX/lwjgl3.

That's interesting, do you think that SPARC and HTS advancements like for example VIPER cables point towards a faster path to market for fusion than ITER?

I don't know about commercial by 2030 but leap frogging ITER doesn't seem far fetched at all because of the all signficant advances in superconductors achieved after ITER was planned out. Also, if the new superconductors do work out, it's very likely that all other forms of energy generation and grid level storage will become almost immediately obsolete and any additional focus moving forward would be only on improving the efficiency of fusion. The remaining use cases for solar would probably then be on small off-grid type situations.

FWIW I think the core devs of Typescript would disagree with you on the characterization that they were in any way attempting to show a large crowd "that soundness isn't an important property." I just say that because such had been my view of the language as well (pragmatism & productivity over type-system strictness) until I had a feature request rejected on soundness grounds a few days ago.

I've never seen that before, looks really neat, I'll have to try it out. Thanks.

This is pretty cool.

Expanding a bit this would be great in an IDE, Often I have wanted to simply select a bunch of files and edit them at once (maybe with a special temporary comment between them) as a single file then save the changes back to the individual files. Would be nice if that was a right click context menu item or bindable command.

In C(++) land I could see it being extremely useful for h/c(pp) juggling if the IDE automagically did the combining.

Finally being able to write the comments that separate the files as I type would be really nice when prototyping out new code you want all together before you split it up.

Also perhaps if its common enough certain meta files that describe link other files together could be left as shortcuts in the repo. When you open those the files (or portions of files) they reference are opened for editing.

This makes me think we should be able to put something like a standard tag for a 1-line summary (maybe embedded in some markdown in a comment) in a fashion the VCS's can detect & extract and then render in their UXs.

e.g. something very simple would probably work like the first line found that matches something like:

   [Ignore_Non_Words]Summary[IgnorePunctuation&Spaces](Capture)

> the effects propagate from one manufacturer to another, while everyone runs to get enough stock to avoid having to close.

Sounds a lot like the bullwhip effect, https://en.wikipedia.org/wiki/Bullwhip_effect

> corruptions of data allocated in the linear memory blocks are susceptible to occur

I don't know if I quite understand this. Is this a web-assembly specific thing, or just the standard C / C++ are "unsafe by default" languages which can cause memory corruption etc because e.g. of off by one errors in pointer arithmetic and so on.

Well, the first place may have predated you and a rewrite is out of the question.

A few other reasons:

The rest of the platform for review and analysis doesn’t have such stringent performance requirements and it would be nice to reuse code.

There also may be some good libraries that are jvm only that your program relies on.

Packing up a fat jar can be a lot easier, less complex and more reliable than building a binary.

Your dev team has a lot Java expertise.

Getting Java to not allocate is not as hard as it seems if you set out to do it from the start. And even if not it’s not impossible because the tooling is so good. You just have to know the right tricks and it can be easier to incrementally learn those tricks for a dev team than learn C++ and it’s ecosystem.

It kind of depends on what you are looking for. It sounds like it's improving compilation times while you develop so you can get errors messages from the compiler and so on faster which SBT incremental compilation should help with.

Are you guys currently using SBT? If so, is incremental compilation not working for some reason (or are you not aware of it?).

In terms of time, it would really depend on the size of the project and what is currently in place. It could be a couple of hours to a few days.

BTW my email is in my hn profile you want to discuss more privately.

I am curious if you are using SBT incremental builds? (putting aside how hard it can be to get and keep SBT working for a project ... I was the guy that had to do that so I know that pain quite well). Because in my experience with really large scala projects that should not be the case, unless you modify a file at the very top of the dependency tree.

We used what I would call the package object predef pattern, which basically involved, rolling your own predef to have certain functions / extension classess / objects always in scope through package objects added to each sub-project. And the build would cross-compile both jvm scala and scalajs. It would not take more than a second or two unless one of those predef files were touched (which would fire off effectively a full rebuild).

Speaking from experience with JVM HFT applications (we used Scala).

There are a lot of tricks though to not require 1TB.

And allocation in general is a bad idea even if you don't collect because it scatters stuff all over memory and messes up cache locality. You really, really don't want to allocate in a performance sensitive jvm application if you can avoid it. It's the opposite of a lot of what I was told and taught (e.g. never do object pooling), but empirically, in my experience, allocations are the biggest slowdown. You can get an application a lot faster just by opening up the memory allocation tab in a jmc flightrecording and refactoring the biggest allocators, usually there is a lot of easy to optimize low hanging fruit that will give good performance improvements, even better than focusing on hot spots in code (in my personal experience).

By far the biggest allocator in trading is going to be marketdata and calculations on it. For reading marketdata from the exchange it's best to leave raw data in memory and access it with a ByteBuffer / sun.misc.unsafe. Under this pattern classes have 1 value, the memory address to pass into sun.misc.unsafe, then everything from there on is done with offsets onto that address. For calculations it's better to write things as static functions, or use object pooling.

In the course of optimizing a trading engine I wrote lots and lots of code to get allocations down to zero. It's definitely doable, but best done from the start, I refactored an existing trading engine to do that, it was not very fun.

Makes me wish there was a Data / spot consciousness swap episode.

Maybe RSS readers?

Paradoxically though if it failed every 1 year then pretty soon maintenance would have to be performed every few months or days or else there would be so many failures it would be really hard to ignore.

So I asked that question a couple months ago and the response that sounded most like a drop in replacement (and better in a lot of ways) was Pop!_OS.

I haven't had the time to try it out yet ... maybe a good weekend project. I've been using Ubuntu for over a decade now so it might take some time to switch over.

Well perhaps with bio engineering we can improve the efficiency of wheat several times over. Optimizing it for an indoor environment free of pests and consistent in nutrients. Ultimately we just want the wheat berries how many protons are spent on the other portions of the plant.

If we do that it would nice to have some experience ready to go on the Industrial farming side.

Also it takes protons to haul the wheat to market, to harvest it, til the soil and plant it. Not to mention all the externalized costs of large scale outdoor agriculture.

Also on mars and the moon beckon, having a closed loop there would likely dwarf anything we can grow on a field here because of the energy costs of moving tons of food into space.

> However, the vast majority of the malicious extensions (245 out of the 295 extensions) were simplistic utilities that had no other function than to apply a custom background for Chrome's "new tab" page.

So I have to make my own browser extensions just for one purpose, to set my own custom url for the newtab page. This is also a problem in firefox. It's quite unfortunate that browsers have moved so far from being user-agents, or at least somewhat attentive to the needs of more sophisticated users that instead of getting more robust tooling for user style sheets, custom javascript, apis to block or modify requests we are either forced into sketchy extensions that replicate the basic functionality or can't even do that because it's outright blocked.

Heck firefox has what seem to be perpetually unfixable bugs with bookmarklets not working on CSP[1] sites (for example github) which contradicts the spec and which never seem to be prioritized for being fixed.

1: https://stackoverflow.com/questions/19822716/javascript-book...

Any suggestions for a periodized program?

> Also, I think recovery will be highly sector and company dependent.

If that’s your hypothesis it sounds like there is supporting evidence, as not all sectors have shared in the recent post crash recovery. Eg a lot of retail still trading near lows.

So I've used ubuntu (Xubuntu, xfce) for quite a while and would rather not deal with this, are there any distros that aim to be ubuntu but without snap?

Because hearing things like `sudo apt install chromium` actually aliases to using snap is disconcerting to say the least if true.

its frustrating, along a similar vein I was trying to export my history from firefox and ... well that wasnt happening.

I think doubling time is a bit faster than 5 days from what I have seen elsewhere, and that might change the math to the 25.5M in that time frame.

I think it was recently fixed, because I remember getting the messages gp mentions but haven’t for a while now.

> the ambiguity of description means that ten different chefs could follow the recipe and have ten different results.

I wonder if a similar analog is sheet music. Ten different musicians could follow the sheet and produce 10 different sounding results.

Iirc didn’t they have it then disable it because of spectre/meltdown?

One minor suggestion: just in case you haven't considered it, is to `favor undo over confirmation`. So when the user deletes a note, instead of asking if they are sure with an alert dialog, just delete the note but also have an undo buffer (or trash can) so they can restore it easily.