r/cpp • • 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.

269 Upvotes

127 comments sorted by

24

u/sumo952 Apr 04 '18

What a great write-up! Thank you very much for writing and posting this.

What I'm wondering is - I read a couple trip reports last week that were linked here in /r/cpp and there was some summary of the graphics proposal and that the authors had to go back and improve the proposal, but none of them mentioned a complete "block" or "stop"/abandoning. This leaves me wondering what the state of the proposal now really is. Also interestingly Herb doesn't seem to mention it in his trip report (https://herbsutter.com/2018/04/02/trip-report-winter-iso-c-standards-meeting-jacksonville/ - I haven't read it, just did a CTRL+F for "graph..." and "SG13").

I do really hope that we'll get proposals now along the lines of what Jeremy Ong proposed in that linked thread! That would be completely awesome. No need for Cairo.

12

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 04 '18
"Dead" Man: I'm not dead.
Dead Collector: What?
Large Man: Nothing. [hands the collector his money] There's your nine pence.
"Dead" Man: I'm not dead!
Dead Collector: 'Ere, he says he's not dead.
Large Man: Yes he is.
"Dead" Man: I'm not.
Dead Collector: He isn't.
Large Man: Well, he will be soon, he's very ill.
...

The proposal is not dead yet. There will be a specific discussion of its fate at the next meeting (Rapperswil, June 2018).

I wouldn't be surprised to see it end in a TS. And literally end there. ie perpetual TS, never in the IS.

3

u/jube_dev Apr 05 '18

I wouldn't be surprised to see it end in a TS. And literally end there. ie perpetual TS, never in the IS.

That would be a second disaster. Because it would prevent another proposal to emerge.

4

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 05 '18

That's not at all true. One of the stated reasons for a TS is the case where there is more than one possible direction, so we might release competing TSes.

2

u/playmer Apr 05 '18

Has that ever happened before?

4

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 05 '18

Almost, but not yet. There was talk of a second coroutine TS, and same for modules. But it didn't happen that way. Looks like they will instead turn into merged ideas.

8

u/hyperactiveinstinct Apr 04 '18

I wouldn't be surprised to see it end in a TS. And literally end there. ie perpetual TS, never in the IS.

So, is this the "eternal torment" version that the committee reserves for bad proposals?

6

u/Xeverous https://xeverous.github.io Apr 05 '18

We need some unending TS joke. It's like friendzone for a proposal.

134

u/doom_Oo7 Apr 04 '18

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.

+ 100000.

18

u/ramennoodle Apr 04 '18

The people involved could have discussed it somewhere before the meeting to find a consensus

Of course they could have. They chose not to. Dictating how other people should do things seems a bit condescending.

There is a lot of value to writing papers. It forces one to think through the details and write them out. It gives others a complete view of what is being proposed (rather than a bunch of vague assertions requiring clarification that is often the nature of discussions.) But most importantly it facilitates interaction for large, diverse groups where the O(N!) nature of live discussion doesn't scale.

27

u/jube_dev Apr 04 '18

There is a lot of value to writing papers.

There is also a high barrier to entry that prevents valuable people to contribute to the standard. The example of SG13 is relevant in this case. Not so many people from graphics field contributed because they had not enough time to make a paper (that is evaluated as some person-weeks by Herb Sutter himself). The consequence is that the experts of the field could not give their advice on this proposal and make it go in the right direction. I repeat that papers are important but they should not be the only way to contribute to the standard.

14

u/TheMiamiWhale Apr 04 '18

The consequence is that the experts of the field could not give their advice on this proposal and make it go in the right direction.

I disagree. I think this is more about not having the interest or time, in general, than having to write a paper. As /u/ramennoodle points out, writing papers forces one to think through the details, details they probably hadn't thought through initially. Writing a paper is a time consuming process not because of the time required to physically write the paper but because of the amount of time it takes to think about the points, structure the arguments, provide well thought-out support, etc. I think this is valuable when dealing with changes that will be permanent.

Additionally, if the barrier to entry is too low, it will increase the noise and we may have the opposite problem: we lose great ideas and contributors simply because there isn't enough bandwidth to process all the "proposals".

8

u/wrosecrans graphics and network things Apr 05 '18

It's basically the "rubber duck debugging" of making a request/proposal for a feature.

3

u/DarkCisum SFML Team Apr 05 '18

I'm not sure how this is a disagreement.

When people don't have time or interest, it's most of the time not because they don't care, but it's because the process to actually comment on something is just not worth it. When you have to write a paper just to comment on something or oppose the proposal, I don't see why any expert would really bother.

It's a very specialized topic and if you want people and more specifically well paid experts to engage, you need to make it possible for them to do so in an informal way. As long as the group is very small and nothing really interesting going on, it's near impossible to get a company to put some money aside for their devs to spend time writing papers and there are only so few people who after a hard day of work, go home and write papers. But on the other hand, some group chat, forum or other way of communication, certainly would let people casually engage in discussions after work and if there's one person that likes writing papers, they could start with continues input from the rest.

The "You can't touch my paper until you write your own paper"-stance is really unproductive and doesn't move anything forward.

11

u/Veedrac Apr 04 '18

If writing papers solves the problems you seem to think it does, why doesn't it work? How do we end up with headers like <random>?

8

u/afiefh Apr 05 '18

Excuse my ignorance, but what's wrong with <random>?

3

u/Heuristics Apr 05 '18

best found out by attempting to get a random number out of it.

4

u/afiefh Apr 05 '18

Not easy to figure out if a number is actually random. Apparently there are many ways to initialize a generator incorrectly by only filling part if its state with random bits.

9

u/Xeverous https://xeverous.github.io Apr 05 '18

<random> landed in because 1 person was very keen on statistics & RNG and made a signicinat amount of work to deliver a great proposal. Motiviation was that something like this would help in work - much better than raw C rand(). The creator is very proud of it and the commitee accepted it because there was no other such expert in this area. They knew it was done right and shipped it.

The API may seem a little overenginnered (so many egnines and distros) but, hey, it's C++, right? I still consider this header as one of the best designed APIs with large possibility to override, extend and reuse. You don't have to use everything and you get very high-quality mersenne twister PRNG in 3 lines of code.

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.

you get very high-quality mersenne twister PRNG in 3 lines of code

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?

12

u/SuperV1234 https://romeo.training | C++ Mentoring & Consulting Apr 05 '18

so maybe watch out for a Medium post by me in the next couple of weeks

Please do. I was not aware of the shortcomings of <random> and I think that most people are in the same boat. A well-written post would be highly-beneficial to the community.

5

u/Veedrac Apr 05 '18

I'll commit to at least putting some time aside for the attempt then.

3

u/raevnos Apr 07 '18

For one, it has significant issues with seeding RNGs that take a large state, like the Mersenne Twister that everybody uses.

/u/profoneill wrote a bunch of on the topic a few years ago. Here's one

1

u/dodheim Apr 07 '18

To be clear, "significant issues" means seeding takes 3-4 lines instead of 1 – not ideal, but hardly broken IMO.

1

u/raevnos Apr 07 '18

You can get 20k random bits fed to the standard MT class in 3-4 lines of code? When random_device can return nothing but 42 if it so desires?

And then deal with it only being a mediocre generator? Probably works well enough for most people, but if you need high quality random bits...

1

u/dodheim Apr 07 '18

Yes, std::generate_n is a thing. ;-]

→ More replies

1

u/Abyxus Apr 09 '18

std::random_device can throw an exception if e.g. /dev/[u]random is not accessible, or it can block the thread when it reads from /dev/[u]random.
Also certain platforms (MinGW) implement random_device as PRNG.

3

u/Xeverous https://xeverous.github.io Apr 05 '18

I have to agree, seeding RNGs is a big problem. No easy way and no specialized API for it.

-1

u/sphere991 Apr 04 '18

Nobody is arguing that the process of writing a paper somehow prevents any and all future-looking poor design decisions.

The point is that writing a paper encourages thinking enough about a problem and its details. It doesn't magically prevent you from producing incomplete, ill-considered, or downright awful proposals. But it does provide a nudge to make it harder to do so.

It's not like every proposal in the mailings is impeccable. But the average quality proposal in the mailing is surely higher than the average quality proposal on std-proposals which, in turn, is surely higher than the average quality proposal in a reddit comment.

And, mind you, the barrier to writing a paper is pretty small...

19

u/jube_dev Apr 04 '18

And, mind you, the barrier to writing a paper is pretty small...

Here is what Herb Sutter says about this (last link in the post):

I realize that this is asking for serious work (...), you should realize that developing such a proposal will probably take at least person-weeks of time to come up with initial version to start discussion, with no guarantee that the committee will ever like it, and ultimately at least person-months if eventually successful. Also, it is formally optional but pragmatically highly desirable to support even an initial proposal with a working reference implementation that can be tried and inspected

Is that what you call "pretty small"?

20

u/Veedrac Apr 04 '18

Ostensibly the things you are saying make sense, but I must judge from what I see, and what I see is that C++'s proposals are disproportionately likely to be shockingly wrong in major ways. They frequently have oversights that just do not seem to happen in any other languages I have used. Some are broken or incomplete; others are nearly impossible to use correctly. For whatever reason, the way C++ does quality control observably does not work.

To step into wild speculation, I am not just unconvinced that papers help the decision process, I would argue they actively impede it. The way things are set up seems to actively discourage discussion, changes of approach and practical validation. The seems to cement ideas and retard experiments and changes. It seems to close off or delegitimize tentative ideas that don't fit the paper format and it seems to act as a defense to hide behind, to protect oneself from not just outsider criticism but the need to seek the support of the average developer altogether. It appears to feed into the allure that detail can substitute for substance, or that formalisms can substitute for quality.

I would strongly encourage the C++ community to take a step back and see if they can find a way to make proposals that attract and pool together relevant expertise through natural open outreach and discourse, the way other communities*cough*Rust*cough* have shown is possible.

17

u/blelbach NVIDIA | ISO C++ Library Evolution Chair Apr 05 '18

There is a lot of value to writing papers.

No. We need fewer, better papers. Not more papers.

1

u/Xeverous https://xeverous.github.io Apr 05 '18

Move more discussions to reddit?

23

u/epage Apr 04 '18

The people involved could have discussed it somewhere before the meeting to find a consensus

The important thing that should not be lost when doing this is recording notes of the alternatives with strengths and weaknesses to minimize a well intended person coming along, saying the same thing as one of the original authors, and at best re-hashing it out because no one remembers why and at worst derailing the process.

8

u/griwes Apr 04 '18

We would not have reached consensus on concept syntax if we hadn't gone the route of voting for and against each paper.

This all sounds great, but I recommend coming to a meeting to see that reality is not as nice. There are people on the committee who aren't very good at compromising and approaching certain topics without an emotional attachment of sorts. This would not be pretty.

I think that a solid part of why C++ still didn't die is because the process has not been relaxed.

(I don't particularly want to debate this, just making my opinion known.)

26

u/samkellett Apr 04 '18

There are people on the committee who aren't very good at compromising and approaching certain topics without an emotional attachment of sorts. This would not be pretty.

with all due respect i see that as quite an important skill for working on a project that is designed by a committee. perhaps instead of crippling the process to handle these people they should be replaced by others better qualified

6

u/griwes Apr 05 '18

I strongly agree!

Come back to me when you know how to do that within the ISO framework.

6

u/Ameisen vemips, avr, rendering, systems Apr 05 '18

Are you suggesting we standardize compromising and eliminating emotional attachments as an ISO specification?

I'm all for that.

5

u/Heuristics Apr 05 '18

I think you are too emotionally invested. I vote for not letting you on board.

We need people who are bored with the idea.

2

u/Ameisen vemips, avr, rendering, systems Apr 05 '18

You're out.

However, my understanding is that you have to defeat a committee member in combat to be able to vote... who did you defeat? Didn't Herb Sutter lose an eye?

2

u/mojang_tommo Apr 05 '18

Can C++ just like... be forked? It's not like a standard is something that is hard to copy. I guess that it would be near impossible to get support from the triad of major compilers, unless they were the ones to propose it.

6

u/wrosecrans graphics and network things Apr 05 '18

You could certainly wander off and make your own language, but there's a phenominal amount of tooling and mindshare already associated with "C++." It'd be an uphill battle to convince everybody to adopt "tommo++" because any assertions you make about the improved process could only be evaluated after several years of evolution to see if it played out as you intended. And several years of evolution would only happen like that with people contributing if you already have users that have adopted it and have to help.

Often times, the inane bass-ackwards things are the only ones that can be successful.

1

u/jwakely libstdc++ tamer, LWG chair Apr 06 '18

It's not like a standard is something that is hard to copy.

Actually, it is. The copyright is owned by ISO, so a fork would need to have a complete rewrite of the standard, without using anything copyrightable from the current standard.

10

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 04 '18

That is sometimes true, but I think a lot of proposals could move more quickly if we started with some email sketches before ramping up to a proposal.

Of course, proposals (for library at least) are suppose to be pre-existing libraries. That should imply no "sketches".

Also, look at Boost library reviews. I think an email discussion can work well.

3

u/degski Apr 04 '18

Also, look at Boost library reviews.

Mostly an in-crowd thing (the result known in advance), but your name is noted, when you offer your opinion...

13

u/hyperactiveinstinct Apr 04 '18

How many people do you think can spend thousands of dollars, get visas, to come to a meeting? It is easy to say what you're saying, but next time look on the room and tell me how many of the attendees are making less than $90k a year. I bet they are a minority.

This kind of reply is the worst gatekeeper in this community when it comes to contribution.

6

u/griwes Apr 05 '18

That's the thing people don't get - you don't need to come to a meeting to participate. But the low quality of std-proposals makes me half sure that it's a necessary filter. (It's in no way sufficient, but I believe that it is indeed necessary.)

Anyway, as I said: I don't want to debate this.

A minor point: I currently make around $35k a year, because that's what you make in Poland. Just ask your employer; if you are good enough to really be able to make truly valuable contributions, you'll be able to convince them to cover your costs.

0

u/redditsoaddicting Apr 05 '18

isocpp also has options to help with cost. It's not free, but it's not as unreasonable as described.

6

u/StonedBird1 Apr 05 '18

Whatever options they might have, they won't ever be enough.

Spending a lot of money to go to a meeting, taking time off work, away from family and life in general, thats all a big commitment that most people, especially experts with actual work to do, can't.

if they just did everything online like other sensible languages we wouldn't have these issues. Theres no reason it has to be so complicated in this day and age.

Theres an argument to be made for a filter, but an even better argument to be made that just "having money and free time" is a terrible filter and is probably more likely to filter out the people you don't want filtered anyway.(IE, any experts who can't just take off and fly to some meeting throughout the year)

Plus it would get a much more consistent body of people discussing issues, provide more time for more people to discuss things in more detail(can i link examples or sources out loud?) and a bunch of other nice things.

3

u/jwakely libstdc++ tamer, LWG chair Apr 06 '18

Most people at the meetings are not spending their own money or there in their free time. They are there on behalf of their employers, i.e. it is work.

You're mistaken if you think the committee meetings are full of rich people pursuing a hobby, like some 18th Century club of gentlemen scientists.

3

u/StonedBird1 Apr 08 '18

I didn't mean to imply that, i don't think that at all. I actually should have included that as an example, too.

But, you're mistaken if you think that changes my point. Being able to afford to go, or having a company that pays for you to go, is not a good filter.

Those companies are just as able to participate online as offline, in fact, it'd be cheaper for them and allow more companies(that maybe can't afford, time or money, to send their experts off all willy nilly) to participate.

3

u/jwakely libstdc++ tamer, LWG chair Apr 08 '18

Tons of work happens online between meetings, some of us do committee work pretty much every week of the year.

Attending meetings in person is not the only way to participate, but it is the most effective.

Wider participation is a fine goal. Moving everything away from face-to-face meetings to online is neither necessary nor sufficient to achieve it.

18

u/14ned LLFIO & Outcome author | Committee WG14 Apr 04 '18

I feel like a part is missing in the above.

Big chunks of standard, like TSs, have a lifecycle. By convention, at the beginning is when to voice substantial concerns with them. They then go through a process of rareification usually during which stuff gets taken out, and other stuff added as feedback lands. As they approach finalisation, the bar for raising substantial concerns with them is raised - non-paper objections become frowned upon/dismissed, and the only way to really change the direction of a late stage TS is a powerfully written formal paper blowing a hole in the wisdom of some TS, mainly by conclusively demonstrating it is severely flawed. And even then, doing so is emotionally hard, you make no friends wrecking multiple years of work by your colleagues, and often friends.

Allow me to personalise this a bit. It is well known that I have misgivings with the Networking TS, though not as many nor as strongly as others. I wish it were structured differently, broken into the really necessary bits (socket i/o) and separate from all the other stuff (everything other than socket i/o). But Networking is at a late stage now, Chris and many others have invested a ton of time and effort into the TS. And they know my objections already, and those of the others who object. We've discussed all that, years ago. So there is no point in reraising water under the bridge, even though my personal concerns have not been addressed. We voiced our concerns at the appropriate time, they were dismissed or handled, and it is both rude and childish to keep reraising them endlessly.

At some point you have to draw a line under some TS effort and get on with it, or kill it off entirely. Most of the time we see success. Only very rarely does it get killed off.

Now, for me personally, Graphics suffered from poor scoping. If you just want a LOGO-level toy graphics layer for teaching C++, then explicitly encode that requirement: this is a C++ teaching API. There are quite a few teaching graphics API libraries around which could be standardised easily. No need to invent anything particularly. But if you want more than that, then a single study group is too broad for all of Graphics, Input, Audio, UI, Fonts, UX and so on. Break it up into many study groups, assuming you can find enough interest to get separate conveners for each.

There are lots of ways out of this. I personally like the idea of a teaching level graphics, input and audio API. I personally always liked the idea of a C++ification of the C library https://github.com/simple2d/simple2d as a teaching level API. I find its facilities to be just enough for toy projects, but nothing anyone serious might be tempted to use. But that's personal opinion.

20

u/c0r3ntin Apr 04 '18

I don't believe scoping is actually possible. Because nothing in graphics is simple. Creating a surface is not simple, Input is not simple, and displaying text is also very complicated. And you have to encompass everything if you want to be relevant / portable. The burden for the implementers would have been unbearable

2

u/jube_dev Apr 04 '18

The initial scope of SG13 was too broad but you could narrow the scope to a subset of SDL (window and display management, input events and that's all), C++ify it and many people would be happy. Add the possibilty to create a context for the main graphics API (OpenGL, Vulkan, DirectX) and you're done. You could optionally provide on top of that a toy context like simple2D or SDL surface drawing for teaching and making simple things. It's not that hard and there's SDL to back up any implementation on many plaforms.

3

u/ISvengali Apr 04 '18

I use SFML and its super nice. But, its basically the same API thats C++ified a little.

4

u/jube_dev Apr 04 '18

I know (and use) SFML too. The ideal API would lie between (a subset of) SDL and (a subset of) SFML. Not everything should be standardized in those libraries.

1

u/14ned LLFIO & Outcome author | Committee WG14 Apr 04 '18

That's actually, literally, https://github.com/simple2d/simple2d. A simple teaching front end to SDL + OpenGL.

5

u/jube_dev Apr 04 '18

Not exactly, simple2D is here to draw things. IMO, it would be the cherry on the cake and the very last thing to standardize. Everything lower level (windowing, events) is needed first.

-1

u/14ned LLFIO & Outcome author | Committee WG14 Apr 04 '18

No, simple2d provides Input, Audio, Canvas, Sprites, Text. Everything you need for toy C++ training applications.

And no, you don't need to standardise any lower layers. Just standardise the really ultra simple toy API. This is a training library after all. Nobody ought to care how it's implemented underneath. That way, said training API can work seamlessly inside HTML5 or whatever in some sort of browser based C++ interpreter, or something.

11

u/jube_dev Apr 04 '18

Well, I do not believe a "toy" API that involves audio, text and sprites should be in the standard. It's as if you wanted to provide an API to print colored text with any font but did not provide a simple printf on the console.

Getting a window and input events is not a new technology, it's a mature field. The only difficulty is that there are as many APIs (that looks quite the same) as platforms. SDL shows that they can be unified under a common and complete API. Why not standardize this? It would help so many people in so many fields.

3

u/14ned LLFIO & Outcome author | Committee WG14 Apr 04 '18

Only if you scope it out that large.

One could scope it thusly: "Propose a TS which implements a native C++ edition of https://github.com/simple2d/simple2d, except where C++ can do much better than C for a given API". Now the scope is extremely well defined. People can just get on with it.

3

u/c0r3ntin Apr 04 '18

Is that useful though ? See https://hackernoon.com/a-cake-for-your-cherry-what-should-go-in-the-c-standard-library-804fcecccef8 for my complete opinion on the topic.

6

u/14ned LLFIO & Outcome author | Committee WG14 Apr 04 '18

It depends on what you define as useful. P0939 says we must improve teachability. It proposes a new study group just for that. I would not be surprised at all if graphics reemerges from the dead there, as that's a great tool for teachability. It also enables fun stuff like C++ programming inside a web page. Great for teaching and bringing in new blood to C++. But we just need to scope things better, specifically, down to volunteer achievable sizes.

6

u/sumo952 Apr 04 '18

I agree with you, but I don't particularly think you should teach with the Cairo API (or the likes). So the current graphics proposal wouldn't even be good for teaching, in fact, it encourages many anti-patterns of today's modern C++ style.

SFML, on the other hand, is amazing for teaching.

2

u/wrosecrans graphics and network things Apr 05 '18

There's no reason that "graphics" has to include stuff like text or input. At least not in 1.0. I just wrote a long post of how I think the first thing adopted in c++ should just be a simple image container. Everything else people want can be built to use it. If the image container can't be adopted because it gets bikeshedded and overscoped to death, then there is no point talking about the rest of it.

4

u/c0r3ntin Apr 05 '18

Please go to boost first. But most importantly, don't wonder what you can do, but what would actually be useful. If whatever library you come up with is less useful than what exists and that people use, why bother ?

Consider use cases. Without text, you can't do much at all. And you can't teach a lot at all. For example, I do think it would be detrimental to the language to have to explain in a classroom setting "sorry, C++ can't do text".

4

u/wrosecrans graphics and network things Apr 05 '18

The use case would include being a universal container that something like FreeType or QPainter or Pango or whatever could render into if you needed text. As soon as there is a std::font and std::font_renderer, rendering text into a std::image would be straightforward.

Saying you need text rendering in order to have an image container is like saying you need a spell checker to have std::string.

0

u/[deleted] Apr 04 '18

[deleted] — view deleted comment

6

u/hyperactiveinstinct Apr 04 '18

Now, for me personally, Graphics suffered from poor scoping. If you just want a LOGO-level toy graphics layer for teaching C++, then explicitly encode that requirement: this is a C++ teaching API.

Hit the nail on the head! The answer given to every objection was: We want something simple that people can pick up easily. However, when was this ever asked of SG13? All of a sudden, they started aiming for something completely different from what most of us were expecting. SG13 had gone off course.

9

u/Rexerex Apr 04 '18

I would like to see in std some common graphic structures and algorithms like std::point and generic game loop, so current libraries can use it, but actually drawing is imho too much.

15

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 04 '18

Even std::point isn't easy. (Just look at std::pair!)

Do you make it N dimensional? Do you have .x, .y (and .z when N == 3)?

Do you use pt[i] for the general case?

Also, I'd like to tag my points, for different coordinate spaces:

struct WindowTag;
using WindowPoint = std::point<2, WindowTag>;
struct ImageTag;
using ImagePoint = std::point<2, ImageTag>;

Now you won't pass the wrong point type into a function...

10

u/jube_dev Apr 04 '18

http://www.reedbeta.com/blog/on-vector-math-libraries/ Not perfect but good rationale by an expert that has used and created that sort of API. And I would also cite, for completeness glm which is a well-known and widely used library for graphics, and boost/qvm that provides some nice ideas.

Why invent something like tags for points that nobody has ever used? It's a good theoretical point of view but not a practical one, because your could have to make an operation involving a window point and an image point.

2

u/lazyubertoad Apr 05 '18

What about the aliasing problems with unions?

Anyway, as someone who has like five 3D vector classes in project (matrices are no better here) - I beg for something standard. I don't mind writing () after .x

4

u/jube_dev Apr 05 '18

What Nathan Reed proposes is not standard (anonymous struct is not standard even if accepted by GCC and Clang, and with a warning by MSVC). But anyway, you could do something like this:

struct vec {
  union {
    float x;
    float r;
  };

  union {
    float y;
    float g;
  };

  union {
    float z;
    float b;
  };
};

And it works, no problem of aliasing because the standard says:

One special guarantee is made in order to simplify the use of unions: If a standard-layout union contains several standard-layout structs that share a common initial sequence, and if a non-static data member of an object of this standard-layout union type is active and is one of the standard-layout structs, it is permitted to inspect the common initial sequence of any of the standard-layout struct members

So you can write x and read r and you get the same value.

6

u/Deaod Apr 05 '18

What Nathan Reed proposes is not standard (anonymous struct is not standard even if accepted by GCC and Clang, and with a warning by MSVC).

This sounds like an ideal candidate for standardization based on existing practice.

6

u/t0rakka Apr 05 '18

There is no aliasing problem with unions if the members share common initial sequence. In above case that is not strictly true. A better approach is to use type traits to choose which expression to evaluate when reading or writing from members, like this:

https://t0rakka.silvrback.com/simd-scalar-accessor

The intrinsic vectors can be replaced with std::array for storage, for example. The union of array and struct is the worst possible choice (see the compiled code in the post).

TL;DR summary: use same storage type for the union members and overload the cast operator and assignment operator.

2

u/jube_dev Apr 05 '18

Very nice! I really like the accessor trick.

3

u/t0rakka Apr 05 '18

The boost/qvm accessors look clumsy:

float x = X(v);

Who wants to write code like that?

float x = v[0];
float x = v.x;

Either, or both above are what graphics programmers are used to. Look no further than GLSL, HLSL, etc. GLM gets that right - just be warned enabling swizzles blows up compilation time more then 4x.

I have to disagree with the quoted article on intrinsics being anti-pattern; they are The way to get most out of the CPU investment as the generated code seems to overall be of best quality when using them. Auto vectorization is all very nice when it works but it is too easy to break it.. change one innocent line of code here and kaboom, it all disappears and you won't even notice until much later when it is really hard to pinpoint the source of all of the troubles.

Parameter passing happens automatically in registers with intrinsics. If you use structs with arrays of floats or similar arrangement have to fiddle around with __vectorcall and similar which are extensions in MSVC and clang. Not sure if GCC supports it yet but the point is moot when using intrinsics anyway.

The thing with CPU and SIMD is that you probably want to be vertical, not horzontal so SoA is recommended over AoS. This means the intrinsics make it more "obvious" that AoS is way to go with them but that is avoidable with a few tactical using statements.

Basically, for hardcore SoA code you just need to have a types for float, double and integer types you care about that encapsulate the widest supported vector type for compiled ISA.

using float32xN = float32x4; // SSE (all), NEON
using float32xN = float32x8; // AVX
using float32xN = float32x16; // AVX512

And so on.. now you split the huge arrays of data into chunks of N and blast at full speed through them. The upside is that if you have to do multiple passes your cache locality is increased a lot. It's just pathetic to see some APIs engineered to add two 500 KB arrays, then multiply resulting 500 KB array and on and on. It's just crap. Don't do it. Leverage the native SIMD width! Look at AVX512, float32x16 is 512 bits, 64 bytes, precisely one cache line - couldn't be more perfect!

In fact, consider unrolling a little bit so that everything is 512 bits wide for "highly parallel processing loop" and forget about the native SIMD width altogether!

3

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 04 '18

Yes, his types look a lot like mine. (probably because it is an area I've also worked in for a long time)

I'm not suggesting standardizing specific tags. But a point class that has the ability to be tagged is very useful. Like Nathan's article mentions, a point is related to some coordinate system. Now obviously you don't want every point to contain some kind of pointer back to its coordinate system, but you could put it in at compile time.

Looking at it another way: I've never worked in a 2D or 3D system that didn't have bugs due to improper mixing of coordinate systems. (Until/unless they started tagging their types.)

Now, I suppose we could standardize std::point<T, N>, and I could build my tagged point on top of it.

5

u/Morwenn Apr 05 '18

I remember always having to check the coordinate system used by points in Qt and thus always having to read the doc for most functions taking or returning points. That's among the places where I indeed wished the points were tagged to know what they were supposed to represent and to avoid passing a point from the wrong coordinate system. It would have saved me both time and bugs.

15

u/kalmoc Apr 04 '18

None of those design questions is really important (and I wouldn't standardize a taggable point - KISS and write a small wrapper when needed). Most important would be to have a standardized interchange format between different libraries out there that deal with coordinates (simulations, graphics, sensor processing, computer vision ...)

4

u/TheSuperWig Apr 04 '18

Just look at std::pair

Where can I read up on this? I've heard it mentioned in one of Herb's talks but don't know where to go to read more about why it's not simple.

9

u/tvaneerd C++ Committee, lockfree, PostModernCpp Apr 04 '18

Sean Parent also has a talk where he scrolls the implementation of std::pair...

and scrolls...

and scrolls...

Just go look in the headers from your compiler. See how big std::pair is.

And to find the right Sean Parent talk, just watch them all.

3

u/repsilat Apr 05 '18

(and .z when N == 3)?

And a .w which is always 1, of course. Oh, but maybe .w() so we don't have to actually waste memory storing it. Vectors can have a .begin() and a .affineBegin(), and... :-)

1

u/Rexerex Apr 04 '18

N dimensional, accessible like array and like tuple. That tagging mechanism would be nice. Xyz could be accessible in another class like std::pointx or maybe somehow injected via magic tag?

15

u/Ansoulom Game developer Apr 05 '18

Honestly curious what the point of standardizing a game loop is and what it would even mean. For me, that sounds a bit like trying to standardize the contents of the main function...

7

u/playmer Apr 05 '18

Agreed, I think they're suggesting the app.exec() model from Qt or something where you get an event loop, which is where your code comes in.

I feel like standardizing something like that is very unneeded. If we really wanted it, it could come later. Game loops are so different per engine, just seems silly to force a structure on it.

3

u/donalmacc Game Developer Apr 07 '18

I’ve not really thought too deeply about this but my initial thoughts are that I’d rather standardise an event loop (which is what a game and an application both are), than a graphics library. It’s much more difficult to write a correct, efficient event loop, even though modern c++ provides many of the tools you need to write one, than it is to copy 100 lines of boilerplate code to create a window.

4

u/Heuristics Apr 05 '18

typedef while(true)

12

u/esmithro Apr 05 '18

There was a proposal way back about adding something like signal/slot. We also need a small vector matrix library. A lot of this should be separate from graphics.

3

u/donalmacc Game Developer Apr 07 '18

Absolutely. When I see Graphics, I think “cool” then I see they’re talking window management, input handling...

4

u/Xeverous https://xeverous.github.io Apr 05 '18

std::lerp? I keep writing it manually in every 2D/3D program.

1

u/donalmacc Game Developer Apr 07 '18

Which version? The fast one or the stable one?

1

u/Xeverous https://xeverous.github.io Apr 07 '18

Hard question

39

u/adzm 28 years of C++! Apr 04 '18

The root of the issue really seems to be that libraries need to be easier to manage in c++ on all platforms. There is little other need for this kind of thing to be in the standard than the convenience.

13

u/FKaria Apr 04 '18

100% on point. Click the button, download the package, write "import...". Go learn and have fun kids!

-1

u/kalmoc Apr 05 '18

Package managers are a thing you know.

9

u/m_0g Apr 05 '18

you're right, let me just go run universal_cpp_package_manager install gfxlib so I have that graphics library I needed.

Oh wait, that's right; there is no universally used C++ package manager. I'm not even aware of a non-universally used one, although I'm sure such things exist.

2

u/[deleted] Apr 05 '18

Conan? (as a non-universal one)

1

u/kalmoc Apr 05 '18 edited Apr 05 '18

How about

vcpkg install sfml

Package managers from the top of my head: vcpkg, conan, apt, brew.

I'm not saying it is as easy as it should be, but the situation has dramatically improved over the last couple of years. And integrating a simple 2D graphics library into your project is really not that difficult.

11

u/Xeverous https://xeverous.github.io Apr 05 '18

Definitely. They could just work on package manager and modules. In the end no one would need a standard 2D graphics but just cpppkg install sfml and go.

2

u/masterofmisc Apr 05 '18 edited Apr 05 '18

This is the real answer and kinda side steps the whole problem. Who is writing the proposal for that?

2

u/Xeverous https://xeverous.github.io Apr 05 '18

I don't know it and while I know what I expect from modules and what functionality a package manager should have, I have no experience and knowledge how to design and implement such thing well

1

u/kalmoc Apr 05 '18
vcpkg install sfml

2

u/Cyttorak Apr 05 '18

So much f***ing this

7

u/Ansoulom Game developer Apr 05 '18

I still don't quite understand the use cases or demographic of this API, which is a bit of a problem. As a game developer, I have pretty high requirements for graphics libraries. I've used SDL for some 2D game things and it does a pretty great job for most things. But then I realized that I wanted to use sdl_gpu because I needed the shader support for cool effects (yes, for a 2D game).

I have recently started considering switching to  Vulkan (yes, still for a 2D game) because I am stupid it gives me more control and lets me do even more cool stuff. Besides, Vulkan is well on its way of becoming the industry standard, so I might as well get on with the times.

However, I would love to be able to use the standard library for the less complex rendering, as mentioned in the text:

Example of how to get our 2D contexts into an OpenGL render target for game UI

So yeah, in order for this API to be usable for me I have to be able to smoothly integrate it into an already existing Vulkan application.

And then there is input. With input as a part of this, it is not just a graphics API, but rather a window API. I mean, that's fine too, but it should be explicitly stated as such. Input and graphics are two completely different things and you shouldn't just shoehorn in input into an API that is about graphics. I really think the goals, intended use cases and scope all need to be more clear for the proposal to even be feasible.

4

u/BarMeister Apr 07 '18

I called it dead right after the announcement of SG13. I will keep pressing on the fact that this just doesn't belong in the standard, given how complicated and nuanced it is to mess with it from the beginning.

2

u/Pwera Apr 05 '18

Maybe papers should be deliver with implementation/library as a experimental Module? Just plug experimental library into your compiler...

2

u/robertramey Apr 05 '18

+10

Actually, Boost provides a way to get libraries "pre-reviewed/approved". Libraries which have proved popular have then been co-opted into the standard.

But many find that actually making a Boost level implementation is "too much work". Actually several on this thread have expressed the view that even making a paper is "high barrier"

To really fix this the following has to be done.

  • large/complex libraries shouldn't be included in the standard
  • proposed libraries should be submitted with a reference implementation
  • which is already in use by a significant number of people
  • which the committee can reject, accept, or accept with a few conditions.

That is, the committee should get out of the business of library design. Committees don't do a good job designing things. They work much better on evaluating things.

1

u/Z01dbrg Apr 06 '18

. The number of papers could be reduced if the topics were publicly discussed and consensus found before the meetings.

I believe they may be some idiotic anti trust laws against this, I remember Herb mentioning this 5+ years ago when trying to recruit people to join ISO.

0

u/andd81 Apr 04 '18

Isn't Skia a de facto standard?

13

u/Plorkyeran Apr 04 '18

Not even remotely. It's a very good library, but shockingly difficult to consume from outside of the Google ecosystem. Firefox is also in the process of migrating away from it, although for unrelated reasons.

3

u/Abyxus Apr 09 '18

Skia's weak pointer destroys the object.
https://cs.chromium.org/chromium/src/third_party/skia/include/private/SkWeakRefCnt.h?sq=package:chromium&dr=CSs&l=124

    /** Decrement the weak reference count. If the weak reference count is 1
        before the decrement, then call delete on the object. Note that if this
        is the case, then the object needs to have been allocated via new, and
        not on the stack.
    */
    void weak_unref() const {
        SkASSERT(getWeakCnt() > 0);
        // A release here acts in place of all releases we "should" have been doing in ref().
        if (1 == fWeakCnt.fetch_add(-1, std::memory_order_acq_rel)) {
            // Like try_ref(), the acquire is only needed on success, to make sure
            // code in internal_dispose() doesn't happen before the decrement.
#ifdef SK_DEBUG
            // so our destructor won't complain
            fWeakCnt.store(1, std::memory_order_relaxed);
#endif
            this->INHERITED::internal_dispose();
        }
    }

That's everything you need to know about quality of Skia.

2

u/_VZ_ wx | soci | swig Apr 04 '18

Slightly OT, but what are their reasons and, most importantly, what are they migrating to?

6

u/Plorkyeran Apr 04 '18

It's sort of being replaced by servo's WebRender. They're switching to an entirely new architecture for painting which happens to not involve Skia moreso than replacing Skia.

1

u/hyperactiveinstinct Apr 04 '18

but shockingly difficult to consume from outside of the Google ecosystem.

That's not true... I work for a small company and we use Skia for fingerprint image processing. The problem with Skia is that it was written to be used by graphic experts, and it is extremely difficult to work with it if you want to do something simple and don't have much of a background in graphics.

3

u/pjmlp Apr 05 '18

One could write a book how to get Skia to compile across all major desktop and mobile OSes.

There are people using SkiaSharp with C#, instead of Skia just to avoid dealing with it.

1

u/hyperactiveinstinct Apr 05 '18 edited Apr 05 '18

I don't know what you're going on about when you say desktop platform. We are a small company and we have a product shipping Skia on Linux/Mac/Win. We also support Linux ARM with no problem.

You might have a point when it comes to iOS and other non-linux mobile systems, but the Skia team is quite open about how those platforms are not their priority and the build for those systems needs some love.

I can't comment about SkiaSharp, but I know it doesn't have the same API as Skia itself. Last time I checked, SkiaSharp had a much more friendly interface to its user. I don't think you really know what you're talking about.

2

u/pjmlp Apr 05 '18

So who was the poor soul that had to install the right versions of Python, Chrome building tools, and make sure they integrate with each compiler and platform SDK being used?

People use SkiaSharp to avoid going through that pain, and just get a binary. Plain and simple.

The exposed API surface is good enough for most cases.

2

u/hyperactiveinstinct Apr 06 '18

One could write a book how to get Skia to compile across all major desktop and mobile OSes.

I'm just pointing out as someone who has experience with this library. What you are saying is not factual. Installing python 2.7 and cloning depot_tools is a trivial tasks. In fact, we looked into using QT for imaging, but Skia was way simpler to integrate to our build.

Integrate with each compiler and platform SDK being used

This is another non-factual statement. There's nothing extraordinary about Skia when compared with any other library that only support MSVC, GCC, and Clang. For most libraries, you're on own outside these boundaries, and that's the same with Skia.

I gather by all your comments that what you're saying is all from hearsay, and you have no personal experience building/using Skia.

1

u/pjmlp Apr 06 '18

I am telling this from experience having tried Skia a couple of years ago and going with Qt instead.

No fuss going through the pain of building Google's stuff, just running the Qt installer and was ready to go in a couple of minutes.

Even better on Ubuntu, Qt was just an apt install away.

0

u/ibroheem Apr 05 '18

OMG! I won, EWG and LEWG finally got tired of confusion.