So, Like, When *did* the Plugin Builder Stop Minifying Code?

Plugin builders
1

I’d been suspecting this for a while, but hadn’t actually bothered to confirm it (because I minify my own code and I like to write with ECMAscript features that Closure doesn’t handle), but I note that the plugin builder no longer seems to minify plugin code at all. This seems like a not very good idea, particularly from a performance point of view, but I’m curious about when that change was made or if perhaps this is unintentional.

Anybody on the Bubble side that can chime in here (@sam.morgan, perhaps)?

I’d observed this quite some time ago, but thought it was just a cool new feature that I no longer had to constantly execute window.do_not_minify_plugin = true. :wink:

I might also be incorrect about this, but I don’t see minified plugin code anywhere that I didn’t DIY. (Happy for any other plugin devs to prove me wrong as I can’t test everything.)

3 Likes
2

We’ve observed this too going well back into last year. Was also surprised when spotted it

2 Likes
3

Thanks for the confirmation, @exception-rambler!

Edit: And I suppose if Bubble should choose to bring such a feature back, hopefully they’ll implement Terser instead of anything else (basically nothing else supports the latest ECMA features, AFAICT).

1 Like
4

Yep - performance is punished!

5

It’s been some time. At least a year and a half.

Automagically Minified code would be nice. I do that with some of mine too.

1 Like
6

There are so many extra bits Bubble is shipping. Though I hated the fact that do not minify wasn’t a setting in General (“Shared” I guess), but a stupid console setting that had to be toggled. :man_shrugging:

1 Like
7

This is important question. Just bumping so Bubble can’t ignore and I won’t forget.

2 Likes
8

But it does help with the debugger though :rofl:

I guess in Bubbles view, it’s the plug-in developers choice to manually (by whatever tooling we choose) to minify or not.

1 Like
9

Except that we can’t minify properly. The old minify (PRESUMABLY) did a proper minification across all fields in the plugin editor.

If you write your plugin code like me (as a monolith in instance) you can minify that and achieve 90-99% minification, but… otherwise…

(Aside: also @lindsay_knowcode, plugins running in their test mode app were unminified, so this was never an issue.)

Also: none of this was/is documented. I hate it when these Bubble employees pop in and are like, well that’s documented or whatever and I’m like… “uhmmm, dipshit, NONE of this is documented.”

1 Like
10

So, you know, when exactly did this happen? And why was that not worthy of any sort of announcement?

11

Nope. It broke some of my implementations after publishing. I am glad it is gone, although a fix would have been preferred.

1 Like
12

Why did this not come up? Again I’m glad Closure is gone, but normal Bubble users have NO IDEA their apps are being jacked by this. (Bump)

13

I really don’t understand why Bubble stopped minifying plugin code (or at least attempting to), but note that my “big” plugins – e.g., List Shifter, Calendar Grid Pro, Floppy, and (just now) Parallels are all released with the main plugin code manually minified.

I’d been relying on Bubble’s auto-minification for Parallels, but since that doesn’t exist anymore, recent versions of Parallels were bigger than they needed to be. This isn’t a minor thing, BTW. The most recent minified version of Parallels (1.0.18) is just 31 kilobytes minified vs. 80 kilobytes unminified (e.g., v 1.0.17).

Note that List Shifter and Calendar Grid Pro have never been released unminified (as I had to do that manually). Some versions of Floppy (the ones generally labeled DEBUG VERSION… DO NOT USE) have some or all of the elements’ main code in unminified states for debugging.

Inside the Bubble plugin ecosystem in general, any plugin that’s been published after [whatever date the Bubble plugin builder stopped using Closure] will be unminified code unless the developer manually minifies their own code. (So this means that old chestnuts that haven’t been updated in forever, like “Toolbox” are delivered in a well-minified form, but others are not.)

And a subtlety here: In some functions, like Update, Actions and perhaps state initialization, some very simple minification is going on. For example, references to instance, properties and context seem to be replaced by single-letter references, but the bulk of a plugin’s code isn’t broadly-speaking minified (like comments and whitespace and whatnot seem to be preserved). So Bubble is shipping a whole lot of unneeded cruft and the better-maintained a plugin is, the more likely it is to be shipping in a more-or-less unminified state, FWIW.

6 Likes