A shocking aspect of Delphi 1 was the gargantuan executables it insisted on producing. There was much forum posting and gnashing of teeth.
Hello World ran to about 100 kB.
Funny thing is, I am just getting into Go, and you know what?
Hello World ran to about 100 kB.
Funny thing is, I am just getting into Go, and you know what?
I have a hello.adb program, 99bytes, compiled 25k
-rwxrwxr-x 1 seg seg 25352 Nov 2 01:26 hello
-rw-rw-r-- 1 seg seg 99 Nov 2 01:23 hello.adb
-rw-rw-r-- 1 seg seg 1409 Nov 2 01:26 hello.ali
-rw-rw-r-- 1 seg seg 1576 Nov 2 01:26 hello.oSo you'd inevitably get some clueless complaints that Ada was so much bloat compared to C, based on comparing the size of a statically linked executable to a dynamically linked executable.
I still laugh about my first Hello World. My friends mocked me for my megabyte-sized beginner programs. It totally was in line with the image of Ada being a bloated, bureaucratic DoD monster. GPS made things feel extra complicated and ugly.
That said, I'm considering to use Ada 2012 for several of my upcoming works.
You can use Electron (and basically bundle Chrome), or JavaFX (and bundle a Java runtime), and they're about the same size. But even if you ship all of the Qt dynamic libs, or all of the GTK dependencies, or even wxWidgets... it's still a far cry from "light".
It just takes tens of megs to make a window appear.
Darkness Lay Your Eyes Upon Me - Conspiracy - Revision 2016 64k
https://www.youtube.com/watch?v=_SEGm2lUSY0
http://www.pouet.net/prod.php?which=67106
After watching a few 64k demoscene demos, a 380MB Electron-based minimalist text editor just seems horribly bloated. (I'm currently writing a cross-platform Windows/Linux/Mac GUI app in Xojo, and the macOS version is 11.6MB at the moment.)
GUI toolkits aren't comparable in this regard.
Adding Unicode support (independent of the Platform) probably bloats every executable an additional 100k. The horror.
I love that Xojo's IDE is cross-platform too, and that I can make my Windows & Linux builds from the Mac IDE. It's been easier for me than Qt anyway, and without any of the licensing or renewal issues.
I wrote my own personal GUI toolkit on top of OpenGL/GLFW for developing special purpose editors (for gamedev), and the resulting executables plus required shared libraries and resources (minus system libraries like libGL that shouldn't be distributed directly with the application) are only about a megabyte or two total. That includes a full blown custom scripting language interpreter, resizable rich text widget with bold/italics/color support + optional text wrapping and scrollbars, JSON parser and serializer, vector math library, a basic image loader and saver for several formats (using stb plus a little custom code for a few less common formats), various routines for software manipulation of surfaces (e.g. drawing lines, triangles, alpha blending images, and so on)... written in C++, with debugging info turned on, and using templates where appropriate. (It'd be even smaller if I stripped debug info and packed the whole thing into one executable.) I'm developing it on Linux, but I could rebuild it for Windows (and probably Mac) without too much effort.
I don't know what the hell the GUI libraries are doing to get so big.
Try it and report back the amount of Kb (not Mb) used.
EDIT: The version on their download page doesn't make GUI's for OSX yet, but there seem to be other versions that do.
That's not quite true. Check out these Avian examples:
https://readytalk.github.io/avian/
Fully statically linked Java cross-platform GUI app (using SWT) in a 1mb download.
If you compiled a Delphi program without using the UI stuff the resulting .exe files were usually only a few dozen kb in size. People used this fact in combination with using raw Win32 API in order to create very small sized UI apps with no external dependencies.
There were tons of tutorials on how to use Win32 API in combination with Delphi.
On macOS the GUI parts are in Firemonkey (FMX) and that is an abstraction layer that does all of the drawing of the controls by itself instead of using the native controls as supplied by the OS.
This creates some extra overhead. There's pro's and cons here. Personally I'd rather had they used native controls instead of FMX as that would look a lot better. But it is what it is.
From there the app doesn't grow as fast, so it is not all bad.
edit: Just looked at the GUI on my app [0] and without any resources it comes in at 16.2MB (so my estimate was a bit on the high end of things)
It can be done, for eg. Rebol/View, a cross-platform GUI circa 1mb in size.
NB. Rebol/View used the AGG library to achieve this - http://antigrain.com/ | https://en.wikipedia.org/wiki/Anti-Grain_Geometry
Steve Gibson at grc.com has GUI utilities that are pretty small. For example, his DNS benchmarking tool is 165 kB.
In the 90s I met this guy in IRC that used Delphi 2 to program a RAT called Hacker's Paradise.
He was very kind with me (I was much younger than him apparently) and shared the source code so I could learn from it since I was constantly asking him programming stuff.
Then later he renamed the tool "Master's Paradise" so he could go legit and sell it to companies and compete with MS BackOffice.
I enjoyed talking with him so much, even though I could barely understand OOP, but the thought of talking to a real developet left me an impression
Hello World is 1MB?
package main
func main(){print("Hello");}
But you need to remember that Go bundles a whole runtime with your executable, something C doesn't do.
Sure it does, not all C compilers are like gcc with the idiosyncratics of glibc.
Also, there is ICC, MSVC, C++ Builder, aCC, xlC, SunPRO, TI C, ARM DS C, ....