caspar

Stash was not an acquisition. Stash was built from the ground up inside Atlassian during its golden age, by a bunch of engineers who really cared about performance. Though it helped that they didn't have Jira's 'problem' of having 8 figures of revenue hanging off a terrible database schema designed a decade ago.

You might be thinking of Fisheye/Crucible, which were acquisitions, and suffered the traditional fate of being sidelined.

(You are 100% correct that Stash/Bitbucket Server has also been sidelined, but that has everything to do with their cloud SaaS model generating more revenue than selling self-hosted licenses. The last time I used it circa 2024, it was still way faster than Bitbucket Cloud though.)

Source: worked at Atlassian for a long time but left a few years ago.

GP suggested 200k over 4 years, which is pretty reasonable.

Last time I checked,[0] this works great - as long as you don't particularly care which specific versions of imagemagick or cowsay you want.

If you do care, then welcome to learning about niv, flakes, etc.

[0]: admittedly 3 years ago or so.

To add to this, in the gamedev space there are a bunch of middleware libraries that are commonly paid for: fmod/wwise, multiplayer networking sdks, etc.

A mod such as Bottleneck Lite[0], plus your eyeballs :)

[0]: https://mods.factorio.com/mod/BottleneckLite

AFAICT, if you don't want to use it then you don't have to - just like you didn't have to use SDL_render in SDL2. That is what was pitched by maintainer Ryan Gordon[0][1] at least.

[0]: https://github.com/libsdl-org/SDL_shader_tools/blob/main/doc... , though the approach that ended up getting merged was an initially-competing approach implemented by FNA folks instead and they seem to have made some different decisions than what was outlined in that markdown doc.

Ah, I managed to dig up the original announcement post[0]; relevant snippet:

> But this is terrible advice in 2021, because OpenGL, for all intents and purposes, is a deprecated API. It still works, it's still got some reasonably modern features, but even if you add up the 22 years Microsoft spent trying to kill it with Apple's seven-or-maybe-twenty, it doesn't change the fact that the brains behind OpenGL would rather you migrate to Vulkan, which is also terrible advice.

> It seems bonkers to tell people "write these three lines of code to make a window, and then 2000 more to clear it," but that's the migration funnel--and meat grinder--that SDL users are eventually going to get shoved into, and that's unacceptable to me.

[0]: https://www.patreon.com/posts/new-project-top-58563886

If you only want to support Windows/Linux/Android, then sure, you can definitely argue that the SDL GPU API is bloat.

But if you want to support Apple's operating systems then you're stuck with OpenGL 4.1 (officially deprecated by Apple 5 years ago) - so no modern GPU features like compute shaders.

You can go the Vulkan route and use MoltenVK for Apple systems, but Vulkan is quite a step up in complexity from OpenGL ("1000 lines of code for a triangle" as people like to say). The goal for SDL3's GPU API is to give you a more approachable (but still plenty flexible) alternative to that.

And similar story for consoles, presumably.

Apparently lots of people asked for "SDL_render but can you add shader support that works for all platforms", so that's the origin story.

SDL3 does also add a higher level audio API - I don't know much about its merits.

SDL3 is still in preview, but the new GPU API is now merged into the main branch while SDL3 maintainers apply some final tweaks.

As far as I understand: the new GPU API is notable because it should allow writing graphics code & shaders once and have it all work cross-platform (including on consoles) with minimal hassle - and previously that required Unity or Unreal, or your own custom solution.

WebGPU/WGSL is a similar "cross-platform graphics stack" effort but as far as I know nobody has written console backends for it. (Meanwhile the SDL3 GPU API currently doesn't seem to support WebGPU as a backend.)

See also https://justine.lol/ape.html

> looks to be cpu bound.

Apparently "Bevy's rendering stack is often CPU-bound"[0], so that would make sense.

To be fair that quote is somewhat out of context, but it was an easy official source to quote and I've heard the same claim repeated elsewhere too. (I'm not a Bevy user but am using Rust for fulltime indie game dev, so discount this comment appropriately.)

[0]: https://bevyengine.org/news/bevy-0-14/#gpu-frustum-culling

> Oh, and we're committed to the bevy integration. bevy_dioxus is already updated for 0.5 and we share corporate sponsors with the bevy folks.

Silly question, but where can I see the updated bevy integration?

It looks like https://crates.io/crates/bevy_dioxus/ is still using dioxus 0.2 and bevy 0.7 - both of which are quite old. Does your official bevy integration have some other name?

As someone who suffered some severe mobility impairment a few years ago and relied extensively on eye tracking for just over a year, https://precisiongazemouse.org/ (Windows) and https://talonvoice.com/ (multiplatform) are great. In my experience the hardware is already surprisingly good, in that you get accuracy to within an inch or half an inch depending on your training. Rather, it's all about the UX wrapped around it, as a few other comments have raised.

IMO Talon wins* for that by supporting voice recognition and mouth noises (think lip popping), which are less fatiguing than one-eye blinks for common actions like clicking. The creator is active here sometimes.

(* An alternative is to roll your own sort of thing with https://github.com/dictation-toolbox/dragonfly and other tools as I did, but it's a lot more effort)

In Firefox, you can go to Settings >> Fonts >> Advanced >> Untick "Allow pages to choose their own fonts, instead of your selections above", then you'll never have this problem again (though you sometimes will end up with others, such as icon-fonts not rendering as icons, and missing out on meta-discussions around poor font choices).

That's basically ChromeOS, right? Some people seem to use it.

Modeless Keyboard Navigation[0] is a fork of Vimium by an RSI sufferer that doesn't have the mode switching element (but does keep all the other actual features); instead you use Control/Alt + whatever key combinations. Basically it's like Link Hints but with more shortcuts.

0: https://handsfreecoding.org/2017/11/22/extensions-now-availa...

> That works great, until you write markdown and paste in into Confluence. Instead of just accepting markdown and formatting it in the same way it does when you type markdown, Confluence puts it between code tags..

If you are in the new editor for Confluence Cloud (i.e. the editor based on ProseMirror rather than TinyMCE), you can sometimes get it to do "the right thing" of converting pasted markdown to formatted text by copying from a different text editor. For example, for me copying from windows notepad always does the right thing, but copying from vscode doesn't.

Any couch co-op game should do this - local multiplayer for up to 4 people is a great way to connect. Forced, Broforce, Gauntlet, Streets of Rogue, Overcooked 1/2, Ultimate Chicken Horse, Speedrunners, Unrailed, Guns Gore & Cannoli, Gang Beasts, etc.

Search for games supporting local multiplayer in steam, then look them up on https://www.co-optimus.com/ to see how many players they support.

See also Grim Dawn, Noita, OpenTTD - basically look for indie studios.

#1 reminds me of Totally Accurate Battle Simulator[0]; it doesn't have skill trees or a meaningful campaign, but does let you spawn a ridiculous selection of units, possess them, etc.

0: https://store.steampowered.com/app/508440/Totally_Accurate_B...

Also an Atlassian here. For anyone wondering, we tend to use Confluence for planning, decisions, team process, tech specs, etc but use an internal view of DAC[0] for code docs. Think Hugo[1] crossed with redoc[2] with a dash of GraphQL support.

Unfortunately the docs-in-repo + PRs-for-updates approach has way more friction for drive-by-corrections/commentary/Q&A from people not on the team, so it's not a holy grail either.

    [0]: https://developer.atlassian.com/cloud/
    [1]: https://gohugo.io
    [2]: https://github.com/Redocly/redoc

Exactly, https://github.com/thoughtbot/fake_stripe works well enough for this sort of thing.

Unfortunately Dragon development has mostly stalled for the last 5 years (Dragon 15 was a leap forward but that was quite some time ago now).

You can still make use of it via Dragonfly (see also Caster[0]) as mentioned by a sibling comment or by using Talon[1] or Vocola.

Having used a computer 90% hands free for about a year and a half back in 2019, I chose Dragonfly then, but would probably choose Talon nowadays - less futsing about and it has alternative speech engine options.

I also recommend looking into eye tracking: the Tobii gaming products[2] work well for general computer mousing with some software like Talon or Precision Gaze[3] - well enough for me to make a hands free mod[4] for Factorio, for example.

[0]: https://github.com/dictation-toolbox/Caster [1]: https://talonvoice.com/ [2]: https://gaming.tobii.com/product/eye-tracker-5/ [3]: https://precisiongazemouse.org/ [4]: https://github.com/caspark/factorio-a11y

You may be interested in this analysis on various recipe formats, along with the proposed "RxOL" notation for explicitly expressing recipes as such a tree based structure[0].

Personally I find RxOL hard to read & edit though, so I have been thinking about whether it would be doable able to infer such tree structures from CookLang's more readable recipe format[1][2].

Ingredients and times are already marked, so surely verbs & follow up mentions of ingredients can be extracted from the text without further annotation? Haven't tried doing it yet though.

[0] http://diyhpl.us/~bryan/papers2/CompCook.html

[1] https://cooklang.org/

[2] https://news.ycombinator.com/item?id=28997309

This is actually explained on the Kickstarter ("The Making of Spintronics" section).

Perhaps you already have ideas on how to solve for this situation, but in case it helps: forcing active record model accesses to go via a layer of indirection can help with untangling this sort of thing: https://kellysutton.com/2019/10/29/taming-large-rails-codeba...

That said, for microservice extraction specifically, a bit of creative metaprogramming/monkey patching of AR to identify & categorize your callers is probably easier.

> In addition, I had to choose, wsl2 and no other vms through vmware or virtualbox,. or WSL with vmware and virtualbox. they claim they work together nicely, but they don't. vmware and virtualbox crash, freeze, and crawl to a halt constantly when hyperv is enabled.

Personally I simply swapped to using HyperV for other VMs when I needed them. Turns out I didn't need them that much anyway once WSL2 got good enough.

As for performance - I game on Windows still with WSL2 turned on. As long as you limit WSL2's memory usage a bit as described in another thread, I haven't noticed any performance slowdown in Windows. (On the other hand, I have noticed that IO on the linux-side is so much faster in WSL2 than WSL1, which was the main reason I swapped as soon as I could.)

VMware's Unity mode lets a window in a VM appear as if it's a regular window on the host OS[0]. OP is saying you can run a cracked copy of Photoshop on Windows and have it "seem native" even on MacOS or Linux (though in practice the usual small things will differ: menu, some keyboard shortcuts, save as dialogs, etc).

I haven't used Unity mode for a case like this but back when it supported Linux guests I used it occasionally to "bring" some Linux windows to my Windows host and it was remarkably good. I was sad when they dropped Linux guest support from Unity-mode, but running vcxsrv and using X-forwarding is a good enough replacement, so I suppose it was a sensible move on their part.

0: https://docs.vmware.com/en/VMware-Workstation-Pro/16.0/com.v...

Nicely done! In pre-COVID-19 times, Atlassian used a similar hack for its catered lunch menus: a hand-updated Trello board stored the menu items, along with some data about which items are vegetarian, gluten free, etc (using labels?), and then that spat out a nicely formatted menu at a well known URL / on some TVs. Little bit of ingenuity goes a long way to avoid having to maintain yet another piece of software :)

One reason is that disparate impls of POSIX utils don't behave as similarly as one would hope. It's easy to cross the line from using flags that are guaranteed to be available to using flags and behaviors only available on your machine.

An example of a mistake I've made like this is relying on `find` on linux to default to searching the pwd if it doesn't have a positional arg. Another is `sed -i` requires a file extension on MacOS, but doesn't on Linux. You can catch these with tests to some extent, but how many people bother running their CI on MacOS just to avoid breaking other devs?

That said, I did work on a production system which happily shelled out to `dig` for DNS lookups for several years; everybody who saw it had a visceral negative reaction, but it also worked well enough that there was no good reason to spend time replacing it.