The myth of "omg only html has different screen sizes" is so pervasive, it's mind boggling.

Desktop apps have had "different screen sizes" forever. This is called "resize your window in any way you want".

I have a rant/thread on this: https://twitter.com/dmitriid/status/1424052193951354881?s=20...

Sure, but I don't recall many programs / games / thick clients that would reorganize the layout of the application (adding or removing elements, reorganizing rows as communs, etc...) At least not 90s era windows programs, and certainly not dos.

Résolution was taken into account in games, to compute a scaling factor, maybe add some screen bars, and that was nearly all - fundamentally, because hardly any program was going to be used in a small, top to bottom screen at all.

So html was just the first one to have to do it pervasively because of desktop + mobile web browsing of the same source - but it could have happened before.

> (adding or removing elements, reorganizing rows as communs, etc...)

The main reason you don't recall apps doing that is that it is a pretty horrible idea in virtually all cases.

Removing big nav bars and moving their contents into drop-down menus is pretty much the standard way of handling resizes across the web. Same goes for multi-column layouts. It would be a horrible idea to keep those things on a phone, just like it's a horrible idea to scale up a phone interface to a desktop browser window.

Having distinct layouts for mobile devices can be a good idea.

Having the interface add/remove elements for this dynamically is (a) obviously not necessary, as my desktop doesn't suddenly turn into a phone while I am browsing, and (b) not a good idea.

It seems like a neat generalisation, but it really isn't.

Just to point out why your statement is misinformed, your tablet turns from a desktop to a phone when you rotate it.

I've been designing web frameworks from the ground up since 1995. Two sizes is not how it works. You don't read the initial size of the browser window, or parse the device data to see if it's mobile, and decide from there which of two layouts to draw (mobile or desktop). You read it on the fly and redraw as necessary. All parts of the interface and the content working together.

Bootstrap, for instance, has xs, sm md lg xl classes and mixins. Often you don't hide interface elements but simply resize them. Font leading and size may change 20 times subtly as you resize a window.

If you don't believe me, load any major website in a desktop browser and play with resizing the window from narrow to wide.

I know that's how people are doing it.

I am just saying it is bad.

How do I know it is bad? I know it because I have to use this stuff.

If done wrong, it's bad because you're on a desktop and seeing a mobile interface when you shouldn't. The Charles Schwab website is an example of that. If done right, it should feel natural on any size screen, and you should have visual cues as you resize. Again, in many cases it's not about hiding UI elements completely, but about simplifying them so they degrade from word+icon, to smaller font, to just icon, to drop menu. Although it's hardly an example of cutting edge design, the overall AWS console handles this pretty well, shuffling what you need into smaller compartments. (Some individual services do better than others). If you open 4 of them on a desktop it's still fairly easy to find what you need, and hasn't yet degraded all the way to a mobile interface. In my app designs there are at least three levels, usually four.

> Résolution was taken into account in games, to compute a scaling factor, maybe add some screen bars, and that was nearly all - fundamentally, because hardly any program was going to be used in a small, top to bottom screen at all.

Are you comparing applications or games? Because games don't have a fluid layout anyway[1], whether HTML5 or native application.

> So html was just the first one to have to do it pervasively because of desktop + mobile web browsing of the same source - but it could have happened before.

No. All the GUI toolkits I have used to produce native GUI applications since at least 1998 had support for ensuring that elements were still accessible after resizing[2]. Even in 1998, Delphi's "anchor" worked better than anything in HTML today.

HTML was the last GUI development system to get this sort of thing.

[1] You can choose one of a dozen preset WIDTHxHEIGHT resolutions. You couldn't narrow the window and still expect to see all the game elements.

[2] I don't remember many native GUI applications that were broken when you halved the width, or halved the height.

One of web's crowning achievements, flex, was available in Qt in early 00s, if memory serves me right.

Do you remember a popular QT app that would turn a row of elements into a column of elements when shrinking a window, though ?

Was it also common to make sure your Qt app was working fine on the small portrait resolution of the mobile computers that were going to be invented any decade now ?

Flex is a layout system (a fairly good one, that I wish had existed on the web since the start. Rows, columns, wrap. Good.)

; responsive is a design considération (what do I as a human being decide should be visible when the screen is just too small to show everything.)

My claim is that "responsive" as a design issue is deeply linked to mobile computers, so it's not a surprise that it was not a big conxern before.

Hmmm, HTML has had layout behaviour that works at all viewports since its inception -- it's just that web developers have often implemented markup that that is inflexible. Just as you could make static/inflexible layout in any of the tools you mentioned, so could you do so with HTML. The regular flow of content on a web page has always been basically equivalent to "word wrap" (I don't know the proper term if there is one). The only noteworthy feature specifically regarding viewport resizing for web pages is "media queries" which wasn't necessary for ensuring a flexible layout.

It was always technically possible to have a flexible layout, it just didn't become popular/"standard" until around when mobile started being a popular medium via which to view that content. The prevalence "best viewed at 1024x768 or higher" was just a symptom of inflexible design & implementation, not an actual technical limitation of HTML.

P.S. I will definitely agree that laying out content in HTML has always been awkward, tedious, and inconsistent across browsers, hahah :)

It did happen before, X Windows Athena and Motif used layouts, because no two X Windows Thin Clients were alike.

Same applies to Tcl/Tk and Java Swing that build on the same principles.

On Windows side, Windows Forms introduced layout manager, Delphi and C++ builder did the same with VCL.

Qt and wxWindows also have layout managers since the early days.

What happens is that people cargo cult how native programming used to be like, and youger generations only care about Web and mobile.

In the 90s we went from 640x480 to 800x600 to 1024x768 in fairly rapid succession, and Windows could be running in any of those modes depending on the user's hardware. Many apps were able to run in any of those responsively, though some would refuse to run without a minimum level.

Boy do I have a story for you :-)

WriteNow https://en.wikipedia.org/wiki/WriteNow was a word processor available for the Macintosh from 1985. Its windows could be resized from full screen (512x342!) down to so small that only part of one character was visible. There was zero reason to support windows so small other than programmer amusement. The interesting thing was that the scrollbars were perfectly usable at any window size, and changed not just their size but their layout to do so. From memory: at a normal size window, the vertical scrollbar looked normal: something like this:

^

|

|

v

At a smaller window size, the scrollbar got narrower, with smaller arrows. This made some sense.

At a still smaller size, the scrollbar shrank again, and the arrows changed shape to be smaller. At this point the window might be displaying two lines of text and the scrollbar was only 20 pixels tall. This was a pointless window size.

At a still smaller size, the scrolling area itself would disappear because the arrows began to overlap. This was a ludicrous window size.

At a still smaller size, the vertical scrollbar changed to horizontal, with two tiny arrows only a few pixels tall, and a teeny scrollbar between them. This was completely pointless.

All of the scrollbar designs were functional.

No.

NeXTStep had resizable windows.

NeXTStep had Interface Builder.

Worked like a charm.

Ok, how about "scrollable page" as the underlying mental model?

Drag and drop a scroll bar: now you have a scrollable page.

Do whatever you want to it.

People who never wrote fluid designs are always the first to tell you it's never been done.

It's still there in MacOS's XCode

When I've looked in the past, Interface Builder was (as far as I could tell) a first-step-and-don't-return thing. Meaning you could lay out an interface visually, but when you want to start coding it becomes a code definition of that interface, and once you start updating that, you can't (easily) return to the visual interface-definition interface. Has that changed, or was I wrong?

Sadly, that's what it has turned into.

Used to be a lot better.

I think "it's tricky" and "it exists" are compatible sentiments.

Not tricky if you spend the time. I'm always speechless when people claim that lack of responsive screen adjustment was the death knell of Flash/AS3. Any language or stack is going to suck on some screens unless you test it on those screens and write code accordingly. Nothing had better performance in this than Flash, up until Google decided to stop letting Chrome fire off new window boundaries on resize until the click/drag was let up. I wrote practically a whole operating system with window managers and apps in a resizable browser window in 2008 using that tool in under 300k. And large portions of the graphical elements were done through the GUI. Do you realize how much more boring and time consuming it is to write every media size CSS subclass and have to test it compared with just drawing multiple sizes of things and changing their positions and filters?

>and write code accordingly

That is exactly the point — now you have to write code, not use a graphical editor.

No, but the sprite/graphic implementation was much less tedious when you could use a good GUI to set up all the small bits instead of relying on a mental map of flex/grid/css to resolve every little padding or margin.

I often write 99% of an app now and spend days dealing with single-pixel discrepancies on screens whereas before, the layouts would likely be implemented before the code to swap between them even started being written.

You always also had to write code.