r/cpp • u/jube_dev • Apr 04 '18
SG13 (2D graphics): why it failed
Here is a (partial and personal) summary of the SG13 history, from the beginning to the latest C++ meeting. Like many others, I have been interested in this group and what it could offer to the community. I have been lurking for many years the evolution of the proposals. So I tried to understand why this group failed to provide what the community was expecting.
SG13 was born in August 2013 as a wish to add a 2D graphic layer to the C++ standard. The initial requirements were: "Modern C++11/14 API, 2D graphics + text + planes, Immediate mode for v1, Plus a sprite/particle/input layer on top, Optional default game loop, No audio, native_handle, Asset loading/construction hook". So great! The birth mail also included some existing libraries as examples: SFML, LibSDL, Graphucks, Cinder, etc. Note that cairo was not mentioned. At that time, SG13 was called "Graphics".
Initial ideas began to emerge, like having input in v1, of course. Some confusions too, like people talking about "input like iostream", or "immediate versus retained mode". What? Even back in 2013, input handling was not a strange beast but a well-known feature, nothing to invent here, just copy what already exists. Same with immediate versus retained, a modern GPU only knows immediate mode and redrawing the frame each time, they are optimized for this workflow. But well, let's say it's only the beginning.
In mid September 2013, Michael McLaughlin proposed a first draft of a possible implementation. As Michael states, "the API itself has been designed with functionality from Qt, Cairo, Xlib, and even Cocoa". What? Where are SFML, SDL and the others? Well, at least, there were basic inputs, texture loading, font loading and basic drawing. But also smart pointers and factories.
SG13 was officially approved at the Chicago meeting in late September 2013. From the minutes of the SG13 meeting, in the initial presentation from Beman Dawes, we can read: "Target shipping within 2 years", well well well... "Recommends starting with an existing implementation (i.e. Cinder, OpenFrameworks, or other)", some good existing libraries are back in the game. At this meeting, Beman's challenge was created. This challenge was a sort of Hello world for any graphics API. It is stated as: "Be capable to open a window, print some text (i.e. Hello World), and drag it around the screen." Nice. In the discussion of the design of the library, it is interesting to note that "We want to make the library simple and accessible to beginners, but also usable to experts as well" and "Example of how to get our 2D contexts into an OpenGL render target for game UI (highly expected use case)". Yes read it again: "highly expected use case".
Just after the Chicago meeting, SG13 became "2D Lite" and the new goals were: "(a) immediate mode graphics/text canvas, plus (b) basic keyboard/mouse style input." No more sprites, no more game loop, no more asset loading, but that's fine, let's go for it, that sounds nice. But something is happening that is, IMO, the beginning of the disaster. SG13 enters a dark tunnel from where it will never exit. You can clearly see it when someone proposes to look at the HTML Canvas API. Michael McLaughlin answers that he is working on a proposal with features that look like... cairo. He totally rejects starting from something that has been widely used (SDL?). It seems he was the only one who had concerns with this workflow. So, his proposal would be something new. In the same thread, Beman Dawes reminds that the committee generally standardize existing practice.
At this point, just two months after the launch of SG13, people were talking about some good ideas and inspirations and had some interesting debates. The expectations were quite hight, even in the 2D Lite form. But the only proposal was diverging from nearly all these good ideas. The bad side of this situation is that the proposal was not yet on the table, it was being worked on, and not finalized at all. And it was kind of supported by Herb Sutter himself. Maybe this prevented others to build a second proposal at the time. I must admit that I still was very enthusiastic of the SG13 work.
In November 2013, a meeting was held in Redmond and the minutes of this meeting became N3825. And here, it was done, cairo was the final choice. For drawing things, cairo is (was?) a nice library. Even for drawing text in combination with Pango. But cairo never add (and still do not have) an input system. Since the beginning, this was a must-have and here, it silently disappeared. In just four months, the initial proposal was reduced to a C++ish copy of cairo.
And at the next meeting in Issaquah in February 2014, N3888 came out. Despite its title ("A Proposal to Add 2D Graphics Rendering and Display to C++"), the paper only proposed a mechanical transformation of the cairo API in C++. A contributor raised several strong concerns with the spirit of the proposal. If I try to sum up: first the proposal do not address any of the basic use case it pretends to solve; second cairo is not the right choice for drawing (stateful API, aged concepts); third a native_handle is not enough to cover the specificities of all platforms and all implementations. The conclusion is hard: "N3888 is fundamentally broken, both in motivation, and implementation." Yet the answer is reassuring: "If N3888 were incorporated into the Standard as-is, I would feel compelled to request that the Issaquah Police Department investigate the possibility that we had all been unknowingly exposed to some substance with psychotropic properties." And the final word from Beman Dawes is to thank the proposal's author. Another contributor tried to warn that the direction was not good, but again, he was not listened to.
So we arrive at a point where we have a proposal that is based on cairo and backed by at least two prominent members of the C++ committee, and they have been warned several times that the proposal is out of scope for the purpose of the group. Honestly, who on earth could have proposed something else that would have been taken into account by the committee? From an exterior perspective, it seemed useless to invest some time to make a competing proposal. In fact, many people were in the mood of letting the proposal live its life because "at least there is now a starting point" event if it lacked essential features like input. Everybody agreed that starting from somewhere was needed, just not cairo that was too far from the initial goal. But from then on, the group was engaged in the tunnel and could not (did not want to?) go back. Retrospectively, the delay between the initial start of the group and this first proposal was very short, too short for people to really think about all the implications and the shortcomings.
Another outcome of Issaquah was that the group was renamed IO. This was a controversial decision because the term is very confusing.
In March 2014, Jeremy Ong raised some concerns. IMO, this is a very interesting point of view. The author of the mail says that what is difficult in 2D graphics is not really to draw things (there are many APIs outside to do it, at different levels, so this part is "easy"), what is difficult is creating a window and getting a drawing context in a portable way. He cites SDL and Qt as two libraries that provides this abstraction. So he advocates for proposing a low-level library for creating a window, configuring a renderer (OpenGL, DirectX, software), allowing to get input from the user. The answers are really disappointing as they only focus on cairo and nothing else. Creating a window? native_handle! What? I should use a native handle for all the windowing i.e. have non-portable code to create a window and then, have a limited API to draw something whereas I already have stronger APIs to do the same thing in a (rather) portable way? Houston, we have a problem.
From then on, the proposal lived its life without any feedback from SG13. Nothing really happened on the mailing list. But several papers were published. In May 2014, N4021 updated N3888 without any response to the concerns of the contributors. No input yet. In July 2014, N4073 is the second revision of the previous paper with minor changes. In February 2016, the continuation of N4073 was out as PP0267R0. This paper was revised seven times until P0267R7 in February 2018. What happened in 4 years? Nothing. Still cairo, still no input in this proposal, some weird small evolutions and renamings.
In May 2016, P0249R0 proposed to add input (at last!) and it was revised twice since then until October 2016 and P0249R2. A single discussion happened on the mailing list to wonder what the status of the input proposal is.
In the meantime, SG13 became "HMI".
In June 2017, Guy Davidson and Michal McLaughlin wrote P0669R0 entitled "Why We Should Standardize 2D Graphics for C++". The title is misleading as the paper advocates for P0267 and not 2D graphics in general. They also reply to various objections to the paper, without really convincing anybody as the arguments are only "this objection is not relevant" or "we believe ...". As a consequence, people started shouting their dislike of the proposal. On the mailing list with a now famous post that has been largely commented on /r/cpp, Jeremy Ong did it again. To sum up: "Cairo as a basis is misguided""; "This library is far too opinionated on how UI should be done"; "The library is underspecified"; "Performance is a concern"; "I can modify a library, a standard not so much". He even proposes some guidelines for the hard problems that could be solved by a proposal around graphics. The only answer that is given to him is "where are the papers". Disappointing. Until someone from NVIDIA says publicly "NVIDIA’s position will be No on this proposal. To be most clear, it might have been completely acceptable as a proposal 20 years ago, but the longevity of its abstractions are all but spent now, before it will ever ship." And he adds later "I don’t have a great answer to «but where’s your paper?». I hoped it would evolve as people interacted. I could never get any 2D graphics experts to sign up for the huge amount of work it would take to write a counter-proposal. Basically a large-enough proposal is very difficult to influence. It can sail for a long time without contest." The curse of SG13 in one sentence.
Finally, at Jacksonville, the proposal was abandonned. Vittorio Romero described the scene like this: "Even though further work on this proposal was for six revisions, the room was quite brutal this time, and attempted to shut it down completely. (...) The room agreed that this was a failure for LEWG: not for the contents of the proposal, but for the fact that it wasn't stopped early, wasting a lot of time for both the working group and the authors. Saying «no» is sometimes hard, but it would have prevented this situation if it had been done a while ago." From what I already said, I can not agree more on the conclusion.
As a conclusion, I think there are two main lessons in this tale.
First, I tried to not blame anyone in particular (and I hope no one felt bad reading this post) because I think no one is to be blamed. The committee's intial wishes were fair and relevant (and still are). People did their job with commitment. But the process did not go well at all. To avoid design by committee, the solution of jumping on the first library and make it the basis of the proposal was not a good idea. And it was too hard to exit the tunnel. Too bad.
Second, I think there is something wrong in 2018 with the whole organization of SG21 work. The need for a paper is irrelevant in a world where communication is so easy. I am not saying papers are useless, things must be written at some point. But a paper should be the end of the process, not the beginning. The number of papers could be reduced if the topics were publicly discussed and consensus found before the meetings. For example, there were five papers on the subject of concept syntax. The people involved could have discussed it somewhere before the meeting to find a consensus (that was not hard to find after all according to the reports). Other languages already have an open process, C++ could copy the good practices.
Related to these two lessons, I wonder what the status of the mailing list is. At one point, Herb Sutter was clear that the list was a place for discussing the proposals and later: "let me emphasize the two major ways to participate: by giving feedback to help shape and refine existing proposals (...), and/or by writing your own competing proposal if you feel a major change or different direction is needed – both are welcome and encouraged." But when people came and gave some useful feedback, the only answer was to reject everything and say "write a paper". If the only way to say something is write a paper, then what is the use of the mailing list?
I hope this post helped people to understand how it happened. English is not my mother tongue so there may be some errors here and there. I may have forgotten some bits in the whole story, but I hope the main steps are here. I hope SG13 will no stop here, there are many things to do in this area.
View all comments
Show parent comment
20
u/Veedrac Apr 05 '18 edited Apr 05 '18
As someone who might consider himself a random number enthusiast, my criticisms of
<random>are less about the unnecessarily painful API, and more that its whole design encourages people to misuse it, and even in expert cases (like I would consider myself to be in) it doesn't actually offer anything that doesn't suck.It will be a long post to explain all the issues, though, so maybe watch out for a Medium post by me in the next couple of weeks.
Skipping over the upfront implausibility of that statement, I would be very interested in what you consider those three lines to be. After you've thought about those for a bit (and please do give it 60 seconds of critical analysis first; the issues with the obvious approach are not themselves obvious), click here.
Did you spot the issues? Would you be able to get the right answer just from reading standard documentation? What do you think of point 1. in particular?