[computerex]

A GUI web site generator is trivial and many already exist. The difference between the web and traditional desktop based programs is that you have a lot more freedom in constructing the experience on the web. Whereas a typical WinForms app is made up of a bunch of drag and drop common controls like the button or text edit, simple text editing and buttons can take many different creative forms to best suit the intended experience.

So I guess another way of saying it is that older desktop based technologies like WinForms are more geared towards purely functional experiences. The web can go above and beyond providing merely functional experiences. The aesthetic and the experience as a whole is important.

[unclebucknasty]

>A GUI web site generator is trivial and many already exist.

>older desktop based technologies like WinForms are more geared towards purely functional experiences. The web can go above and beyond providing merely functional experiences.

Not talking about web sites here, but web apps, which in the modern sense are much more aligned with desktop apps than websites of old.

[computerex]

I meant web apps. Modern web apps offer a lot of freedom in constructing the precise experience we want the user to get. This is unlike traditional desktop applications with the cookie cutter controls that behave the same way from app to app.

[unclebucknasty]

That's not been my observation when it comes to SPAs, responsive apps, etc. They tend to use fairly straightforward components, layout schemes, etc. For instance, if you look at the components/layout capabilities that come baked into the latest version of Bootstrap, you'll find a lot of bases covered.

Regardless, there's nothing that precludes you from wrapping any control you desire into an interface that makes it droppable and configurable through a GUI editor, then have it generate code. Likewise, for the creation of different layout managers, though in practice I don't think you'd find a ton of variability there. Most "experiences" boil down to grid-based and responsive.

So, I'm not sure which precise experiences you imagine couldn't be created. It's all just code. But, if there are some, then they'd be the exception, not the rule.

[computerex]

https://www.strikingly.com https://www.squarespace.com/ https://www.wix.com/ http://www.layoutit.com/

You can already create simple websites with tools like above. But non-trivial SPA's can't usually be constrained by tools like that because they don't allow for enough flexibility.

It's not that the web hasn't caught up to GUI editor paradigm that has been around for decades. In fact WYSWYG web editors were common when the web was in its infancy.

[unclebucknasty]

>non-trivial SPA's can't usually be constrained by tools like that because they don't allow for enough flexibility.

Yeah, you've kind of repeated variations of that vague statement, to which I've replied with specific capabilities/features that SPAs and modern webapps tend to use. I've suggested that they represent very common features/layouts that can readily be constructed with the aid of a GUI tool.

But, here, you've now responded with a few website builders that are not intended to be used for the kinds of SPAs/modern webapps we're discussing. That doesn't make a point, except to say that "other things exist".

Do you have specific examples of SPA/webapp functionality that cannot be readily built with the aid of a GUI tool?

[vram22]

>This is unlike traditional desktop applications with the cookie cutter controls that behave the same way from app to app.

Controls in desktop apps are not just "cookie-cutter" (if I understand correctly what you mean by that). They can be subclassed in C / C++ / Delphi etc. code, to add to, or override, the functionality as well as the appearance of the superclass control. (And individual desktop app developers can, did, and still do this. It is not necessary to buy or downloads such custom controls, anyone can write them - like you say for the web.) This was being done way back in Windows (from as early as Windows 3.x [1]) and probably in Unix too (X-Windows). In fact, X-Windows may be the source, or one of the early examples, of the famous saying "provide mechanism, not policy" [2], which is related to this topic. (What that saying implies is that policy - which often involved look-and-feel - could be, and was, provided by higher layers, than the lowest layer, Xlib, which provided the mechanism (for X's style of client-server GUI programming.) I've not checked their implementation details, but probably both GNOME and KDE (which both look and behave rather differently from each other, though both are fundamentally Unix desktop environments), are built on top of X-Windows (in its newer avatar of XFree86 or whatever it is called these days).

[1] I just did this Google search for the term "paul dilascia windows programming book", and the first search result is:

http://www.amazon.in/Windows-Writing-Reusable-Schulman-Progr...

which is a book by him called "Windows ++: Writing Reusable Windows Code in C++ (The Andrew Schulman Programming Series)" - which was considered an influential book at the time (see Wikipedia page link below). I had read it, years ago, out of interest, even though I was not doing much GUI programming at the time. It showed (with code) how to use C++ to wrap the procedural (WndProc), event-driven Win 32 GUI API in C++ classes, not only for more reusable code (as the book title says), but also how to subclass existing Windows controls and add more functionality to them, or change their appearance, etc. In fact, IIRC, his Windows++ framework completely hid (from the developer) the traditional, error-prone, manually coded WndProc window procedure style of programming, that was the staple of raw Win32 GUI programming. I was quite junior as a programmer at the time when I read the book, but remember thinking even then, that it was something significant that he was writing about, and the book helped me to understand some of those deeper topics to some extent. To describe it another way, the book basically contained the full C++ code for something like a smaller version of MS's MFC or Borland's Delphi or other OO Windows GUI frameworks that wrapped the lower-level raw Win32 GUI API, which involved writing a lot of low-level procedural boilerplate code (with a hand-coded event loop for each app you wrote). That was some general background and history, but more relevant to your point, it shows that customizing controls is very much possible and done in desktop apps too (not just in web apps). And you do not need to write your own GUI framework in order to customize controls, either. You can just take classes from an existing GUI framework that you use, and subclass those classes, and add or override functionality, including both look-and-feel and behavior. The second search result is Paul Dilascia's Wikipedia page - https://en.wikipedia.org/wiki/Paul_Dilascia .

[2]:

http://wiki.c2.com/?PolicyAndMechanism

https://en.wikipedia.org/wiki/X_Window_System_protocols_and_...

[vram22]

Also, related, google for the term "windows owner-drawn controls". I just did, and here are a couple of relevant links:

https://msdn.microsoft.com/en-us/library/windows/desktop/bb7...

(above page's subtitle: "Creating Owner-Drawn Controls")

Using Visual Styles with Custom and Owner-Drawn Controls:

https://msdn.microsoft.com/en-us/library/windows/desktop/dd3...