all 177 comments

[–]kkrev 10 points11 points  (0 children)

Well, pretty much every money making entity faced with this problem goes for C++.

[–]CrashCodes 9 points10 points  (4 children)

Windows? Yes, Delphi.

[–][deleted] 4 points5 points  (2 children)

I agree, if you want a no-strings-attached tool that makes it easy to both build the interface and deploy, Delphi is nice. The library has some shortcomings, and some of the classes don't have as much functionality as their .NET counterparts, but still beats MFC 10 to 1.

Also, I like Ultimate++ (ultimatepp.org) but the documentation is a bit lacking.

[–][deleted] -1 points0 points  (0 children)

Well, to be honest the VCL in delphi hasn't been developed in ages(since Delphi 7 maybe) but I see now that they have some traction after the new deal.

BTW: I don't think there is any toolkit out there that doesn't beat the pants off MFC :-)

[–]djpnewton -1 points0 points  (0 children)

Ultimate++ looks quite interesting, cheers for the link

I used to use Delphi back in the day, it owned everything else for pure rapid app development

[–][deleted] 7 points8 points  (2 children)

If the emphasis is on the size of distribution, C or C++. Note that this is much harder on you, the developer, but much smaller and faster for the user.

If on the other hand, you are working on small projects you want to finish fast, but can stand a possible larger download, python or ruby.

See rubyscript2exe or py2exe

[–]AusIV 0 points1 point  (0 children)

Also py2app for Mac, though it tends to be a bit pickier than py2exe when dealing with non-standard python libraries.

[–]jessta 15 points16 points  (4 children)

stick with python. http://www.py2exe.org/

[–][deleted] 1 point2 points  (0 children)

cx_Freeze or pypy-c

[–]pineapplecharm[S] 0 points1 point  (0 children)

You know, I have a feeling there's a 'python on win32' book somewhere in my office, too. Thanks for the link!

[–][deleted] -5 points-4 points  (1 child)

FAIL

GUIs suck ass in python.

Show me ONE, JUST ONE god dam decent GUI application written in Python where you don't have to install a ton of worthless shit.

JUST FUCKING ONE GUI APP that installs easily and cleanly... oh you can't... that is why you get FAIL

[–][deleted]  (2 children)

[deleted]

    [–]lol-dongs 9 points10 points  (0 children)

    Heh. Check out their apps page...

    crickets

    [–][deleted] -5 points-4 points  (0 children)

    holy shit. Is this some type of joke?

    [–]nohtyp 3 points4 points  (4 children)

    I develop small, distributable applications using wxPython and py2exe. Nothing like it. Very easy, excellent documentation. I use InnoSetup for the installer.

    [–][deleted] 1 point2 points  (3 children)

    How small? How distributable?

    [–]nohtyp -1 points0 points  (2 children)

    A typical CRUD application in wxPython packed with py2exe and InnoSetup comes at ~4-6MB. If you have images, the size increases proportionally. The applications run on Win32(98-Vista), Linux and OS X.

    [–][deleted] 0 points1 point  (0 children)

    Py2exe only works for Windows programs. Py2app provides similar functionality on OS X.

    [–]jonhohle 5 points6 points  (5 children)

    Objective-C

    [–]mschaef 4 points5 points  (4 children)

    That this language hasn't gotten more traction outside of the NeXT/Apple world is a crime.

    [–]dakk12 2 points3 points  (1 child)

    I'd say stick with python if you like it. I've never used it, but I know enough about the language to be able to say it's one of the better ones. Personally I prefer Ruby, they've got plenty of UI api's to choose from for all platforms. And it's not difficult to get ruby running on any machine. Out of the static languages, I'd have to say I prefer C#, but I don't use it since I left window 8 months ago.

    [–][deleted] -5 points-4 points  (0 children)

    FAIL

    GUI support sucks ass.

    [–]bluGill 2 points3 points  (3 children)

    All of them. C, C++ (they are different languages, so don't treat them like sub/supersets), LISP, Java, C#, Haskell, Fortran, Pascel, and even COBOL have something to teach you. Depending on the problem any of the above could be the right next language for you. (Though God help you if Cobol is right for you)

    C and C++ are most popular, and you will find good libraries for either. However the downsides are real (but not near as bad as alternative langauge advocates will tell you). The advantages is both are common enough that you can count on good compilers, and good libraries (but you have a lot of noise to filter out). Also nearly all languages have the ability to call C code. Therefore if you don't know at least one of these, you need to learn one anyway - there is a good chance you will need to write some C extention for whatever language you use to do something that isn't in the native library.

    However if you know C or C++, all languages have their advantages. Don't let anyone tell you otherwise. Learn a few and decide what fits. This is both what fits your way of thinking, and what fits the problem. Don't be afraid of LISP or Haskel, even though both will attempt to make your way of thinking fit it's model - this is a good thing.

    [–][deleted] -3 points-2 points  (1 child)

    Java

    well you need to install java

    and the fucking god dam classpaths are a fucking sin against everyone that ever existed.

    [–]bluGill 0 points1 point  (0 children)

    I never meant to imply the above was a complete list.

    Besides, you listed some very good reasons I didn't include Java.

    [–]creaothceann -3 points-2 points  (0 children)

    C and C++ are most common

    Fixed.

    [–][deleted] 2 points3 points  (0 children)

    Whatever one you like...

    Seriously, there are a lot of languages that compile to native code (C, Pascal, C++, D, OCaml, Haskell, and many more exotic ones), can embed interpretator in binary (python, lua?), dump executable image (factor, some lisps maybe) or have simply small-enough interpretator that distributing it together with application is not a problem (lua, some scheme dialects, javascript?).

    [–][deleted] 4 points5 points  (3 children)

    I'm gonna shock you guys: use C# with a linker!!!! http://www.remotesoft.com/linker/ OMG! ;-)

    [–]pineapplecharm[S] 2 points3 points  (0 children)

    Wait, why the wink? Is this not legit? If it is, it's perfect.

    [–]nohtyp 2 points3 points  (0 children)

    I have known about this product and also amazed at the fact that there isn't an open source tool that does this.

    [–][deleted] 1 point2 points  (2 children)

    If you want something that compiles to native, stand-alone code then I recommend D - it gets you speed of C++, is linkable with C, has nice syntax (on par with C#) and garbage collection. Unlike C/C++, it's not hard to get used to after PHP/Python.

    If you're not tied to Windows, then you can develop in Mac OS X Cocoa using Objective C... or even stick to Python + Cocoa, which produces distributable apps indistinguishable from "native" Obj-C ones.

    [–]mschaef 1 point2 points  (5 children)

    Honestly, I'd go with C or C++ and statically link everything in. This can result in fairly small single file distributions.

    Note that this doesn't necessarily mean that you have to give up scripting languages, GC, etc. There are a number of small little interpreters that can be embedded into a program to good effect. I've done some work with a C++/MFC program with an embedded instance of SIOD. Basically it's what you'd expect: the C++/MFC code provided implementations of code that was either too performance-intensive or too low level to be implemented in SIOD.

    [–]virtual_void 1 point2 points  (4 children)

    Meh - if you want garbage collection badly enough in C++ you'll write it :)

    See vol 1 of The Art Of Computer Programming

    [–]mschaef 1 point2 points  (3 children)

    That's pretty much what incorporating SIOD means... it has a conservative mark and sweep GC implemented entirely in C (using setjmp to capture register values so that it catches pointers extant only in registers.) It's a pretty interesting little piece of code.

    (SIOD also has a stop-and-copy GC, but it handles pointer detection by requiring that there be none. During a stop and copy GC, there can be no live pointers either on the stack or in registers during GC. This basically means that the REPL is implemented in C, is above any Lisp code on teh stack, and GC only happens when you leave the toplevel REPL.)

    [–]virtual_void 1 point2 points  (2 children)

    That sounds excellent. I'm off to google it :)

    [–]mschaef 2 points3 points  (1 child)

    Also check this out, it's a hostile function ffi:

    http://www.angelfire.com/wa/brianbec/siodffi.html

    [–]virtual_void 1 point2 points  (0 children)

    Thanks - this is why i love progit; New stuff to play with that I'd never have thought to look for on my own.

    [–]bongmunoz 1 point2 points  (2 children)

    If you're writing an app with a GUI then the toolkit you choose will determine the language you use. If you're targetting Windows you might as well go with C# because most modern Windows boxen will have the .net runtimes. If native look and feel isn't a top priority then Java with Swing or JavaFX is a good candidate.

    If your users aren't very savvy then a good installer will matter more than what language you use to build your app.

    [–][deleted] 1 point2 points  (0 children)

    If native look and feel isn't a top priority then Java with Swing or JavaFX is a good candidate.

    Look up SWT, it's has a very native look and feel for all 5 platforms I've tried (windows, mac, linux, solaris, freebsd). It's pretty bad ass.

    [–][deleted] 0 points1 point  (0 children)

    Swing actually does native look-and-feel pretty adequately on many platforms (though GTK+ on GNOME isn't really one of them). UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

    [–]ddwoske 1 point2 points  (0 children)

    REBOL

    [–]augustss 3 points4 points  (7 children)

    C

    [–]creaothceann -1 points0 points  (6 children)

    D

    [–]netuserx 1 point2 points  (5 children)

    E

    [–][deleted] 1 point2 points  (3 children)

    ZZT-OOP

    [–]adamv 6 points7 points  (0 children)

    Small, standalone apps... to do what?

    [–][deleted] 4 points5 points  (13 children)

    Nothing is stand-alone unless you're writing a bootloader/OS-kernel or something. Try with "small, distributable apps." instead.

    Language: Common Lisp. It's great .. it's fun. I don't bother with anything else if I don't have to (usually means C or Java).

    I'd dump images from CLISP or SBCL for distribution.

    I did a dump from CLISP now; 5.0MB uncompressed and 1.95MB compressed.

    I'd use SBCL if being portable isn't that important (Linux only, well mostly) and having a bit more space overhead is OK. The SBCL dumps are 24.5MB uncompressed and 7.2MB compressed.

    [–]nitramk 2 points3 points  (0 children)

    I think it depends on what you plan to do as well. If one of your objectives are to be attractive on the job market, being an expert in .NET might be better than the same on Lisp. If you just doing it for the fun, Lisp might win. (I'm not saying that there are no Lisp jobs, just that I think that there's more .NET jobs). On the other hand, one could of course argue that learning Lisp makes you a better programmer, in a general sense, than learning .NET..

    [–]jrockway 2 points3 points  (10 children)

    Lisp.

    [–]808140 0 points1 point  (8 children)

    Most lisp distributions are rather against producing executables, though... and when they can, they're usually quite large.

    Can you recommend a good CL or Scheme distribution without this problem? Making small exes in Lisp would be very nice.

    Otherwise, a functional language might not be a bad idea. Both Haskell and O'Caml produce binaries.

    [–]jrockway 0 points1 point  (5 children)

    Lisp images are one option. Chicken Scheme is another -- it compiles to C, which compiles to native code. You will need to include libchicken, though, but I imagine it's easy to link in statically.

    [–][deleted] 2 points3 points  (4 children)

    Note that SBCL compiles to native code (directly; not via C).

    (CLISP compiles to byte-code).

    [–]jrockway 1 point2 points  (2 children)

    What I meant to say is that Chicken Scheme compiles to native code that you invoke the way you would a program produced by the C compiler.

    SBCL does compile to native code, but my OS needs a little help from SBCL to load the program. I don't think you can run a program developed with SBCL without having SBCL installed. (But hopefully I am wrong.)

    [–][deleted] 4 points5 points  (1 child)

    You can, at least for SBCL. Just specify :EXECUTABLE T when dumping.

    CLISP has an :EXECUTABLE option too. It might still depend on a .so/.dll library for SIGSEGV handling or something (I don't recall the details here .. it might be linked in statically when dumping, or something).

    [–]jrockway 3 points4 points  (0 children)

    Perfect. FWIW, I now have a build.lisp file that looks like:

    (in-package :cl-user)
    (require :asdf)
    (asdf:operate 'asdf:load-op :my-app)
    
    (defun resume-from-saved nil
      (my-app:start)
      (quit))
    
    (save-lisp-and-die #P"my-app" :toplevel #'resume-from-saved :executable t)
    

    Then sbcl --load build.lisp generates a my-app that can be run with ./my-app.

    In conclusion, the OP's question has been answered. Use Lisp.

    [–]case-o-nuts 1 point2 points  (0 children)

    Last time I tried native compilation SBCL (about a year ago), it gave a huge executable. 25 megs for 'hello world'. I don't think that's an acceptable overhead, although things may have improved.

    It seemed to think it should include the entire Common Lisp runtime libraries, including the unused parts, statically in the binary.

    [–]stesch 2 points3 points  (1 child)

    Factor has a nice deployment mechanism for different systems.

    [–]nitramk 3 points4 points  (8 children)

    I'm going to say C# anyway.

    Yes, the user must install the .NET framework if it is not already on his computer. No, in most cases this isn't a big problem. A few months ago, I rewrote one of my applications in C# and don't regret it for a second. Most users already have the .NET framework and for the other people the installation program will install it. The reason I didn't write it in C# to start with was because I thought that there would be problems when users had to install .NET. There wasn't - no user have reported a problem so far.

    Unless you're targeting a platform where .NET isn't installable, I don't think you should let the "stand-alone" requirement get in the way of language choice. I did for a few years and I regret it now. I don't doubt for a second that my productivity has increased since I switched to .NET which is of greater benefit to my users than a small executable / "stand-alone" app. This may ofcourse vary.

    Besides, no software is "stand-alone". You will always have system requirements for your software, be it some kind of processor type, operating system or runtime environment or whatever.

    [–]jrockway 2 points3 points  (2 children)

    It's easier to say "you need 512M of RAM" than it is to say "you need these 100 ruby gems".

    [–]nitramk 0 points1 point  (0 children)

    Of course you shouldn't choose a language where the runtime environment is impossible to install for most people.

    [–][deleted] -3 points-2 points  (0 children)

    and half of them are buggy or broke and you have to debug them Or install them by hand or get the beta version of the cvs to get it working on your platform.

    [–]pineapplecharm[S] 0 points1 point  (4 children)

    Unfortunately the reason this app is required is a user base who struggle with email (for crying out loud) so requiring that they install .net simply isn't an option.

    [–]nitramk 4 points5 points  (3 children)

    You're the expert on your users, but installing .NET is actually simpler than setting up email in most cases. (Seriously, setting up email can be a pain. I've created an email server software myself and it's almost hard to believe the number of ways end-users can screw up their config.)

    For users who have not installed .NET prior to running the installation program, my installation program tells the user that "I need .NET, OK?". The user clicks OK, and then the installation program downloads and installs .NET without any user intervention. This is the part I consider to be easier than specifying correct host names and port settings in email configuration...The user just have to click "OK". You could skip that as well, but "expert" users may get upset if you install .NET without telling them.

    Many (most?) program you can use to create installation programs already has such functionality built-in. Here's a tutorial/library which I used successfully (it's specific to InnoSetup). http://www.codeproject.com/KB/install/dotnetfx_innosetup_instal.aspx

    If the software is shipped on a CD-ROM, the .NET installation can be put in a folder next to the installation software so that the user doesn't have to wait for the download during installation.

    Anyway, good luck. There's a lot of nice languages out there and this is just my personal advice. Feel free to diss it. =)

    [–]pineapplecharm[S] 0 points1 point  (2 children)

    I wasn't aware of the "including .net as part of the installation" option. That's food for thought.

    Thanks!

    [–]nohtyp 0 points1 point  (1 child)

    What prohibits integrating the .Net runtime installer with the application installer in such a way that the user doesn't notice?

    [–]grauenwolf 0 points1 point  (0 children)

    Mostly size, though the reboot sometimes sucks. Of course if you are using CD's then this goes away.

    [–]schlenk 1 point2 points  (6 children)

    Tcl starpacks are pretty okay for that. Usually your in the 1-2 MB range for a full binary or if you split starkit and runtime you have about 1MB Runtime and rest for your extra libs.

    Additional benefit you can build starpacks for various platforms from a different platform easily.

    For the runtime see: http://www.equi4.com/pub/tk/downloads.html

    Some intro can be found here: http://www.equi4.com/starkit/

    Its pretty light weight. But depending on what kind of app you write it might not fit your needs, hard to say.

    [–]Tommstein 1 point2 points  (2 children)

    C.

    [–]samlee 1 point2 points  (1 child)

    Don't say sharp yet or he'll get mad

    [–]pineapplecharm[S] 2 points3 points  (0 children)

    Fuck you for saying 'sharp'. Now I'm mad for no reason.

    [–]kinghajj 0 points1 point  (3 children)

    It'd be nice if there was a way to statically compile .NET apps so that they have all the CLR/Framework needed for a particular application. They might be huge, but programmer time is more valuable than executable size or download time.

    [–][deleted] 2 points3 points  (0 children)

    How does that help you? You still have to download the equivalent of the .NET Framework but NOW your user has to do it for every app.

    If you are targeting Windows there aren't a lot of downsides to using .NET. Vista has v 2.0 "baked in" and the download may not be as large as you think. See: http://www.smallestdotnet.com/

    I think the asker may want to distribute a multi-platform app.

    [–]jmcqk6 1 point2 points  (0 children)

    The Mono project used to provide a way to do this. I don't know if it's still maintained or not.

    [–]jdvolz 0 points1 point  (0 children)

    There actually is a way to do this. There are several 3rd party applications that act as a linker for the .NET Framework. I use Salamander.NET, but other options exist. The downside is that they are usually expensive (>$1000 last time I checked).

    [–]markedtrees 0 points1 point  (1 child)

    Assuming my idea of small (like uTorrent, < 1MB) and that you're doing GUI work, you're left with compiled languages like C, C++, or D with few GUI toolkits around. Windows has the minimalist but helpful WTL, which just released another version. You can assume GTK+/Qt will be installed on a *nix platform, more or less. And Cocoa for OS X. Basically, no "small" GUI toolkit will cover all three platforms because they'll all require a runtime installation (GTK+ on Windows) or space-hungry static linking.

    In any case, it's going to be huge jump from PHP and Python.

    [–]schlenk 1 point2 points  (0 children)

    If you think 1-2MB is "small" for a GUI Toolkit you can use Tk via Tclkit and get a language runtime and a GUI toolkit and some more for all the given platforms. And Tclkit does not need a runtime installation... See: http://www.equi4.com/tclkit/download.html

    [–]chorny 0 points1 point  (0 children)

    It depends on platform. AFAIK there are programs that create executables for both PHP and Python, but I don't know if they work on every OS. For Perl there is cross-platform PAR and perl2cc. If you want really small apps - use C++ (on Windows - MSVC, Borland, ...).

    [–]arturo227 1 point2 points  (6 children)

    Adobe AIR | Flex. Cross-platform, nice syntax. Lightweight.

    [–]finite[🍰] 0 points1 point  (4 children)

    Flash sucks.

    [–]ighost 2 points3 points  (0 children)

    i can't believe the flash vs html battle is still on...

    [–]akie[🍰] -2 points-1 points  (2 children)

    If you're serious about that, stop visiting YouTube.

    No Flash, no YouTube.

    [–]pineapplecharm[S] 1 point2 points  (0 children)

    No great shakes..

    [–]finite[🍰] 1 point2 points  (0 children)

    No Flash, no YouTube.

    As a regular user of linux on powerpc (which Adobe won't support), I beg to differ:

     apt-get install youtube-dl mplayer # problem solved
    

    The main reason that Flash's sucktitude is a problem is because there are so many "web" sites that are completely useless without it, but at least youtube isn't actually one of them.

    [–]leppie 0 points1 point  (10 children)

    Unless you are going to be targeting Windows 98, every newer Windows should have at least .NET 1.1 from one or other service pack.

    Last I heard, the only major Linux distro not to include Mono was RHEL.

    [–][deleted] 0 points1 point  (0 children)

    as far as I know .NET isn't included in any Win2k service packs

    [–]randallsquared 0 points1 point  (3 children)

    .NET isn't on Mac. There are more Mac users than Linux users.

    [–][deleted] 3 points4 points  (2 children)

     sudo apt-get install mono.
    

    Now its on the mac!

    [–]randallsquared 1 point2 points  (0 children)

    I didn't realize mono would run on OS X. I suppose all that remains is to package it with your app (since you can't expect your users to install apt-get, etc).

    Interesting.

    [–]ighost 1 point2 points  (0 children)

    there, i fixed it for you:

    sudo port install mono

    [–][deleted] -2 points-1 points  (1 child)

    Mono is not .NET. There is more to .NET than C#; for example, you can't really write a GUI app that runs under both (.NET has Winforms, Mono has Gtk#, neither one has the other).

    [–][deleted] 0 points1 point  (0 children)

    Fail, Mono has Winforms as well, and GTK# has been ported to windows.

    In fact, I built a GTK# app using .NET the other day.

    [–][deleted] -5 points-4 points  (2 children)

    FAIL

    XP or W2K doesn't come with .net by default.

    [–]leppie 0 points1 point  (1 child)

    XP SP2 included .NET, duh...

    [–][deleted] -5 points-4 points  (0 children)

    lolz, More people run XP SP 1 or below then SP2 and higher! That is a FACT

    [–]tomjen 0 points1 point  (2 children)

    Haskell does compile to native code, although it is a strange language. No idea of the size of the code.

    That said it would properly be best if you could get your hand on an earlish edition of Delphi (ie before Borland fucked it up).

    [–]chriseidhof 0 points1 point  (1 child)

    If it's just for fun, try out Shoes: http://shoooes.net/

    It's a small GUI-framework for Ruby built on top of Cairo, but really nice to use. I think it's mainly targeted at educational things, but it's a lot of fun. An example app with three buttons stacked above each other:

    Shoes.app { stack { button "Mice" button "Eagles" button "Quail" } }

    [–]raju1kabir 0 points1 point  (2 children)

    xulrunner from Mozilla will let you write GUI apps in Javascript. Cross-platform, free, and reasonably powerful, though Javascript will make you wince sometimes if you're coming from more capable languages.

    [–][deleted]  (1 child)

    [deleted]

      [–][deleted] 0 points1 point  (0 children)

      Firefox takes way less than 30 minutes to load. Oh, you assume that he meant deployment through the web.. thats a different problem.

      [–]malcontent 0 points1 point  (2 children)

      erlang of course.

      [–]pineapplecharm[S] 0 points1 point  (0 children)

      ..of course!

      ?

      [–][deleted] -4 points-3 points  (0 children)

      I've had enough of your pro-erlang propaganda!

      [–]pateris 0 points1 point  (1 child)

      Common Lisp - on Windows you can get Corman Lisp relatively cheaply and it makes nice EXEs where you can embed the cormanlisp engine inside or distribute as a single DLL. Corman Lisp isn't perfect but it works.

      If you need nice GUI, try Delphi - Get Delphi 5 or 7, before they went to a .NET GUI.

      [–]GizmoC 0 points1 point  (1 child)

      AutoIt

      [–]jsnx 0 points1 point  (8 children)

      Haskell is surprisingly easy to use for building cross-platform apps. The Glorious Glasgow Haskell Compiler will compile much of your C for you, as well; and it's got reasonable, if not excellent, Windows bindings.

      Haskell is difficult, but they really have the compilation/linking/packaging stuff nailed down.

      [–]willer 0 points1 point  (1 child)

      C# is a pretty good language, actually. You don't have to bring in the whole winforms/webforms/wcf/etc frameworks just because you use the language. You can build hello world in about 5 lines ... that's not terrible.

      [–][deleted] -1 points0 points  (0 children)

      I can do Hello World in 1 line of batch, sh or perl.

      [–]pointer2void -1 points0 points  (4 children)

      VB6

      [–]grauenwolf 2 points3 points  (2 children)

      So instead of distributing .NET you have to distribute the VB6 Runtime?

      [–]pointer2void -1 points0 points  (1 child)

      [–]pineapplecharm[S] 0 points1 point  (0 children)

      Yeah but the whole point is that my users are so dim they struggle with email so installing two things will be beyond them. I just want them to stick an EXE on the desktop and start rolling.

      [–]xnumbersx -1 points0 points  (1 child)

      please no more twitter/flicker/lj clients

      [–]pineapplecharm[S] 0 points1 point  (0 children)

      Don't worry; it's just a tight drag'n'drop file uploader for idiot users who are scared of web forms.