benjaminjackman

Does anyone have any experience or knowledge about the process of porting a Godot game to consoles?

I know it’s not built into Godot because all the sdks/apis are behind NDAs for the consoles, I was wondering how difficult it is, what it entails and if anyone has experience going the suggested route of hiring the company on the Godot site to do the porting.

More so than performance this would be the biggest blocker for Godot I would think ( not that it’s in any way it’s Godot fault ... it’s consoles being consoles )

> But among the projects I've seen where performance has been an issue, it's largely been the product of a developer's failure to understand how the engine is processing their content, and by extension their failure to architect their game around that.

What are some pitfalls everyone is falling into and what needs to be understood conceptually about how the engine processes scenes?

I’ve found a lot of good documentation and videos on getting started and particular workflows (eg animating), but haven’t see any regarding performance optimization or what Godot is doing “behind the scenes”.

There really needs to be an always ask next to don’t ask again.

I’m personally not upset just worried about the fact that security is now a huge risk because you’re having to trust an extension creator that has access to your entire browser history or worse and who is one auto-update from turning to spy or malware.

You also have a discovery problem having to wade through multiple options increasing your surface area to malware exposure.

IIRC this isn’t even theoretical it’s happened with ones that replaced user style sheets, another “unused” feature that was gradually deprecated.

Maybe the best way forward is to take an apple iPhone approach and have official extensions, similar to the apps that come with the iPhone like the podcast one.

Then when these features are removed they are instead moved to an official extension. Thereby mitigating the security risk and alleviating the discovery problems.

The community can take over these extensions and you have a starting point to personally adapt and fork them that is a lot simpler and faster than trying to maintain a browser fork.

Further the browser maker can more directly see usage of these feature replacing extensions

And finally, when removing features ensure the extensions api has the power to support their replacement.

That's a really interesting approach. I wonder if there are reading apps which have that dictionary integrated, but which still require a mouseover / tap to display it for a particular word (they are just using a translation language dictionary).

Let me just say I didn't mean to come across as overly negative, I think everyone working on the extension has done a fantastic job, it's a very minor quibble in the grand scheme of things I use multiple different machines so while my settings sync over, some of the "we've already shown the user the popup" stuff might not be (or maybe i need to sync more settings). I just am not a big fan of pop-up notifications in general so turning them off is the first thing I do when I can.

Other minor stuff like that (none of this is at all urgent):

- Having an option to disable requiring a confirm for kernel restarts.

- Smooth scrolling in the interactive window regardless of the higher setting from vscode / electron that disables smooth scrolling.

- Don't scroll on output in the interactive window unless it's currently scrolled to the bottom (Allows reading things at the top while more results scroll in w/o having to fight the scrollbar)

- A bit better support for jupyter magics / builtins without displaying errors (e.g. things like %%html or %%javascript or !ls or 'display(dataframe)' all show errors)

In terms of why I like the split display:

I think it's more conducive to writing re-usable code than Jupyter and I can re-read things in the order that I ran them. It also keeps the code closer to together so I don't have to jump over a bunch of intermediate results when I go between different area of code.

Thanks for making the interactive window, it's been a real pleasure so far and overall I really powerful, I wish it was in every language!

Overall I really like this extension and especially its interactive programming / notebook features. I am a big fan of jupyter notebooks, and wrote my own version for Scala (it was more inspired by Mathematica since Juypter didn't exist yet) a long long time ago.

However having all the output be in a dedicated window as this extension does, that allows for scrolling back in the order things were run rather than in the order they are laid out in the notebook is turning out to be better for some use cases. Also, it allows having the output side-by-side which takes better advantage of the horizontal to vertical pixel ratio of monitors.

Another thing I like is that editing cells as plain text using #%% to separate them is just a better more intuitive interface for a programmer than having a bunch of separate text-areas (imho). And it nicely dodges all the padding and unnecessary white-space problems that a Jupyter notebook has compared to a mathematica one, allowing more information to fit on the screen.

For one downside: I haven't ever used an extension that is so inclined to randomly pop up with tips and surveys while I am programming as this one. It's incredibly annoying and I've spent a lot of time trying to figure out how to disable it. Including looking through the code on github, but don't see anyway at all to do it.

It's a catch-22 situation because VS Code doesn't have the option to disable notifications like these, the person in charge of deciding if there should be a feature to prevent popups says that it's an extension issue and to take it up with them. And the extension clearly doesn't have the mindset that it is an issue and frankly I don't think it's an extensions job to re-invent the wheel on this every time so I don't blame them. They are using the tools they have as extension authors because it's clearly not the extensions job to set the style of of notification deliver to the user, only that there is one to present, perhaps with an associated urgency level. The IDE ought to then deliver it in the manner most desired by it's user.

Contrast this with Intellij which works around all of this by simply having a thought out system for notifications, wherein the user, can force them all to go to a log in a panel without a popup, which, for me is great because I'm coding, don't knock me out of the zone!

I don't know if you meant it to parallel the Bezos quote about blue origin / the desire to push our species out across the solar system but it came to mind right away when I read what you wrote because I have been thinking along similar lines:

"The solar system can support a trillion humans, and then we'd have 1,000 Mozarts, and 1,000 Einsteins. Think how incredible and dynamic that civilization will be," Bezos boasted during a speech at New York's Yale Club, which was transcribed by Business Insider.

I wonder if can't figure out something as simple as how to allocate the basic rewards of our system socio-efficiently if the future will turn out more like "The Expanse" than "Star Trek". And if we focused on simply getting all the near-Einsteins out of the patent office (as you said) here on Earth first how much faster the goal of colonizing the star system would be achieved.

Maybe it will be possible to compile Sqlite to wasm and then using indexdb as a backing store for it. In which case perhaps a good enough polyfill would be accessible to Firefox.

Never say never, they are literally in the same building here: https://i.imgur.com/lz7evie.jpg

> Current battery technology is right on the edge of where it needs to be. It means most designs have to be pretty small, very light, and short range. 1-2 people. 30 to 100 miles. Not at all like an improved conventional small airplane, if that's what you wanted. To get around these limits, you "just" need either a revolution in batteries, or hybrid fuel/electric vehicles. The path to the engineering solutions is now clear, though social problems are still many.

Having to stop and switch battery packs / vehicles even at the low end of 30 miles doesn't seem like a big deal to me as a user. And if these are deployed as part of ride-share service which owns all the equipment, which I think would make sense, I think that type of model would be feasible.

>“Cognitive spaces are a way of thinking about how our brain might organize our knowledge of the world,” Bellmund said. It’s an approach that concerns not only geographical data, but also relationships between objects and experience. “We were intrigued by evidence from many different groups that suggested that the principles of spatial coding in the hippocampus seem to be relevant beyond the realms of just spatial navigation,” Bellmund said. The hippocampus’ place and grid cells, in other words, map not only physical space but conceptual space. It appears that our representation of objects and concepts is very tightly linked with our representation of space.

That is certainly how I think I think ... I think :) As an experiment two years ago, I bootstrapped an IDE from an html file with just textarea that could overwrite it's own source on a webserver (it would restart the server if the server code was changed) in the browser. Eventually I got it to the point that it laid out the editors for individual files in an infinite plane of 2d space (akin to something like placing editor windows in a google maps like scrollable ui) and saved their locations between refreshes.

I still really miss the spatial sense that the file that controls the editors is up over there, and the file browser code is right over at that location, (and they slightly overlap their tests and other supporting files).

I had this vision of this sort of becoming a system wherein everyone could choose to see all the files in the system being edited in a shared global space (or perhaps space of workspaces). So if you wanted to see what so and so was working on you'd just navigate over to area where the files they are working on are located. By default if you were editing a file in this system in a public repo, since it was browser based it would be publicly viewable.

Juggling editor tabs and re-opening and reorganizing windows, and not being able to create workspaces of editor layouts since then has kind of sucked. It's like having this glimpse of a system that was from some future time but then having to abandon it.

Given that the implementation of setInterval is far from trivial[1], that is likely correct.

1:https://overreacted.io/making-setinterval-declarative-with-r...

Would be interested to find out because if its just uncalibrated plotting out the relative differences it still would be useful (e.g. seeing a X% increase on whatever scale the sensor using at night versus day could provide enough of an indicator that something is going on and more investigations are warranted.)

Having experimented with and used proxies a decent amount, the MDN page is my goto reference when I need to use them: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

The biggest pitfalls, in my experience are

1. Infinite recursion when implementing get and printing proxies with console.log in node.js (which attempts to access properties from the object prototype which can lead to infinite recursion problems).

2. Performance, which I would need to do more digging and benchmarking to comment on in more depth.

Some libraries that use Proxies to great effect are the https://github.com/mobxjs/mobx-state-tree and https://github.com/mweststrate/immer libraries both by mweststrate

> If you need to login to a captive portal that redirects, there's always neverssl.com

There's also:

http://http.rip

(which is easier at least for me to remember for some reason)

I remember looking forward to the Sunday paper for the electronics store ads more than the paper itself (except maybe the sports section).

Just an FYI: The Dijkstra map algorithms mentioned in the article can be used for a lot more than just pathfinding.

I’ve used them in a hobby game I’ve been developing with a lot of insight from http://www.roguebasin.com/index.php?title=Dijkstra_Maps_Visu... To implement things like determining if resources are connected to an in game road network. I’ve also used them extensively for the game’s AI for all sorts of different purposes.

Truly a handy tool to have in a game maker’s belt.

And that is sort of solving a language verbosity problem with classes and inheritance and the fact that to mixin behaviors classically one would use inheritance but it doesnt compose well and had problems passing things up to different constructors.

Functions work better if you can call them because you can more easily select and add them ala carte and pass individual different specific parameters to each one whereas with inheritance you get one call to super (and advanced react components already extend a class further complicating super calls).

So it is best for one behavior having to only add something in one place to use that behavior. The class model fails because some behavior goes into ComponentDidMount and others go into ComponentWillUnmount and so on.

Hooks solve that. Everything required can be trvially bundled into one thing in one function call.

At first glance the biggest weakness I see for them is that they a bit too magical and that they operate at bit more dynamically than I think would be ideal. They rely on functions being called in the same order and waiting until functions are called for the first time, which seems like the opposite of “declarative”.

Having said that I’ve used them a bit and really like how much they cut down in boilerplate I just wish we had a something that felt a bit more like first class language supported (even if that support requires patching in something like jsx) I just don’t know how that would look or if it would look any different. It just feels like this is scratching deeper itch than just a react only problem but I can’t quite explain how (and maybe I am mistaken for that hunch). Maybe a more expressive language like a lisp would offer a hint at the solution.

Do any cars pull themselves over when they detect flashing emergency vehicle lights? That would’ve probably worked here and might be the ultimate answer.

I think they fundamentally json is just the wrong format for these files. Speaking from (ancient and limited) experience I made a little notebook-style interpreter for learning scala back in 2009 or so called scalide. It saved its files ("scalapads") to XML. XML actually worked better in some ways since most of the code could live between the tags unescaped (sans < > &) so it merged / diffed the user code well. The meta-level stuff (cell boundaries etc) needed by the notebook ... not so much.

In json the code has to be escaped into strings, and json is really finicky about syntax (e.g. no trailing commas). So it doesn't work well.

I never got the chance to redo it, however the solution I was leaning to for my post "I won the lottery, I can work on fun stuff" attempt was to store the meta-code in a version of the host language(s), with some simple syntax that could live comfortably in the comments of various different languages to do things like encode the cell divisions and so on.

Basically something like: #notebook[lang=python]

#cell[lang=python] def add(x,y): return x + y #endcell

//notebook[lang=scala]

//cell[lang=python] def add(x: Int, y: Int) = x + y //endcell

This I think would be beneficial for a couple of reasons.

1. Better diffing / merging.

2. One click toggle between show source and view as notebook mode, which would really allow this to work in an IDE like vscode pretty seamlessly. The cells become something akin to //#regions in the IDE. But at the end of the day you are still editing a source code file, so you can edit the whole file easily.

3. The keyboard shortcuts for executing and jumping between cells would generally work in raw code mode, so you could just edit there continuously and manually writing out //cell //endcell. Also the executing results could appear in block comments inline in the editor, off to the side, or in a popup above, the code you are editing.

4. The IDEs could uprender the comment-syntax into cells as they gained better support for the paradigm (similar to how they do for code folding / syntax higlighting already).

5. Eventually, perhaps a cross language, metasyntax could be established to make things a bit more concrete than magic comments (get ready for some serious bikeshed painting though!)

The closest I have seen anything come in this regard is Quokka however it's not quite all the way there.

>But if I give them 1USD and get back 1USDC, which later can be exchanged back to 1 USD, where are they making money?

Historically that's basically how banks have made money. Issuing bank notes while earning interest on the capital they hold. Typically they juice the rate via fractional reserve lending, ie they lend out more money than they have. However if they aren't able to do that, they still get to keep the interest from the deposits (say by buying Treasuries).

My guess is that the stable coins will continue to be more and more common, but then cryptocurrencies will rediscover fractional reserve lending, and new ideas like pegging a coin to the S & P. The pegger will charge a small service fee, the holders will be able to rapidly move money they spend, almost instantly between S&P (or other basket) pegged coins and stable coins.

There will be enough competition over being the holder of stable coins and enough competition in that system they I would expect them to offer rebates on transactions, and not have to charge merchant fees. And since they will be centrally cleared and not have to deal with mining and so on, the transactions ought to clear instantaneously.

For some reason the notion of Economists “Pour[ing] water on the flames” of a bull economy made me think of the doctors “bleeding out the bad humors” from the front page story here a couple days ago about the techniques used in treatment of George Washington’s final illness.

Am I the only one that finds that the DDG’s bang commands actually make DuckDuckGo more useable than google, even for googles own products? E.g. it’s faster to type in a location and append !gm after (which will cause DuckDuckGo to redirect immediately to searching within google maps itself) than it is to click around on google to bring the maps up? (Likewise for google express !ge google images !gi and especially YouTube !yt)

My only wish would be some way to customize them and add new ones as they almost make web browsing into using a command line (and what that would be like with aliases and adding scripts to PATH).

Do you have a recommended guide for setting an XMPP server that supports end-to-end encryption?

While searching for more information on a configuration value mentioned in the article (javascript.options.wasm_gc) I came across another article on the topic, which I also found interesting because it's a bit more technical:

https://blog.benj.me/2018/07/04/mozilla-2018-faster-calls-an...

Minor clarification:

The DOM builtins should be helped by the Reference Types Proposal for WebAssembly. [1]

`The host bindings proposal` is going to help speed up new and getter/setter calls. [2]

1: `Currently the only built-ins that we support this for are mostly limited to the math built-ins. That’s because WebAssembly currently only has support for integers and floats as value types.

That works well for the math functions because they work with numbers, but it doesn’t work out so well for other things like the DOM built-ins. So currently when you want to call one of those functions, you have to go through JavaScript. That’s what wasm-bindgen does for you.

But WebAssembly is getting more flexible types very soon. Experimental support for the current proposal is already landed in Firefox Nightly behind the pref javascript.options.wasm_gc. Once these types are in place, you will be able to call these other built-ins directly from WebAssembly without having to go through JS.`

-- https://github.com/WebAssembly/reference-types

2: `there are still a couple of built-ins where you will need to go through JavaScript. For example, if those built-ins are called as if they were using new or if they’re using a getter or setter. These remaining built-ins will be addressed with the host-bindings proposal.`

-- https://github.com/WebAssembly/host-bindings

(BTW I could be mistaken, just quoting the article)

It hasn’t been my experience most of the games I’ve tried have worked pretty flawlessly but I also don’t play a lot of AAA games.

> I'll stick with being forced to use it for games only.

Steam just got an upgrade that automagically runs a lot of games via a modified version of wine (called proton) sometimes even with better performance than on Windows. It's worked very well for everything I have tried it with so far. So that just leaves games not available in Steam. The biggest of which has to be Blizzard, however a lot of their games already worked decently well with Wine, so hopefully proton works with them as well.

As of today most games may actually already run better on Linux than on Windows.

Whether or not fusion is possible (it seems like it is, just incredibly difficult and meticulous, unless the MIT-ARC project works out).

There is always the eventual option to harvest solar energy in space The primary limiting factor at the moment is obviously the insane price of rocketing stuff into space.

Perhaps even before that solar power could be harvested in the upper atmosphere on massive scale by being tethered to balloons, it might even have the benefit of counter-acting some of the effects of global heating.