The Lounge is rated Safe For Work. If you're about to post something inappropriate for a shared office environment, then don't post it. No ads, no abuse, and no programming questions. Trolling, (political, climate, religious or whatever) will result in your account being removed.
I looked into it when it first came out in the early 1990s. My reactions then was that "This framework takes over so much of the program logic that it will hijack the entire application and make it extremely difficult to adapt to another [i.e. non-Windows] application!"
The application was planned for multi-platform - Windows was certainly not as dominant then as it has become now. Today, making a Windows-only application is perfectly fine. But as far as I have seen, MFC today is no less (rather more than in the beginning!) a "framework" in the straightjacket sense. It dictates how you write your application logic far more than I appreciate. I wanted to see it as a "library" rather than as a framework, a library that could be replaced by another library (on another platform) without affecting the program logic very much. It didn't appear that way to me, certainly not in the 1990s.
For some reason, I never got that same feeling with C# and WPF. Maybe that is because I have more experience now and simply ignore the elements that try to force me into an application design style that doesn't suit me. Porting C# applications to other platforms is not a very relevant question today, nevertheless I feel that I am the master, WPF is my servant. With MFC it was the other way around, as I experienced it.
Most things, yes. I still use it and run across overlooked things on occasion.
What is really angering me right now is how many bugs I have run across and they seem to have zero interest in even addressing them. For example, if I do a build with MFC in a static library my app can't access any 'built-in' resources like bitmaps. This means things like the file browser control won't have bitmaps on its button.
"They have a consciousness, they have a life, they have a soul! Damn you! Let the rabbits wear glasses! Save our brothers! Can I get an amen?"
Actually, I pity that the mainloop didn't catch on as a programming model
I am not talking about the mainloop itself, but the idea of event-driven programming - designing and implementing your application as a state table: The FSM driver is 20-30 lines of code. Whenever something happens - an event - it indexes the 2D state table by the current state and the event, to find the action to perform and the next state. The state table is where the program logic is expressed.
The action part is application specific code, but you'd be surprise by how few different actions are required, and how simple and fucnctionally isolated they are. 95+ percent of traditional program flow control is replaced by the "next state" logic. In a properly designed FSM application, each state tansition and associated (when required; it often isn't) action is so rapid that there is very little need for any preemptive scheduling (which 16-bit Windows didn't have).
In a proper FSM design, event transition is conceptually instantaneous, from one consistent state to another consistent state, avoiding all racing conditions. "Synchronzing" is not a relevant concept. Complete error handling is very easy to achieve: For every emtpy state table entry, i.e. any state/event combination for which there is no well defined meaningful transition from the current consistent state to another consistent state, you fill in an error action. Any table entry that doesn't have a (normal or error) action filled in will glare at you, reminding you: You must handle this error!
To keep state tables to a moderate size, it is common to accept a few well defined "state variables" accessible for testing and setting from the action routines. In some FSMs, the logic of testing some of these variables are put into the state table: Each state/event entry may list a small sequence (usually no more than 3 or 4) alternate actions guarded by logical expressions on the state variables.
Probably the most complex protocol in the entire OSI protocol stack family, the X.225 Session Protocol, is described by 32 states, 80 events, 79 predicates and 34 transition actions. The 79 predicates can all be expressed as a one-line boolean expression. Most of the 34 actions fill less than 50 lines of code (assuming a proper service interface to the Transport layer). From an FSM modelling point of view, X.225 is a beauty! (I am not saying that the protocol is, I am talking about the modelling of it!)
The old Windows message loop model is ideally fit to this kind of modelling. That's what I am missing: That sort of modelling!
If I, anno 1985, had had the divine power to choose between steering the software world into OO or into FSM, I would definitely have chosen FSM! I still think so - maybe because I learned to code in a style that adopts at least 75% of the OO benefits even without a trace of OO language syntax. On a solid FSM foundation, that coding style becomes quite natural. It has been shown empirically that OO concepts certainly does not naturally lead to FSM style of thinking!
You can do FSM implementation style even within a traditional sequentially-algorithmic framework, if you can succeed in casting everything that happens into one homogenous "event" concept. (That can require some effort!) The major problem is that your co-workers probably has no clue about FSM modelling and want to cast ten minute computations into single state transition actions, and might challenge you into a fistfight if you don't accept it... Computer kids are not trained to do FSM today. That is a pity.
If after that fistfight you need to calm your nerves a bit, search up some old telecom guys. They know what FSM is all about!
Very interesting post, could almost be an article. Better write one up, because FSM application would be very interesting.
I agree with you about the program logic part. FSM would make it completely simple technologically and maybe that part of the message loop should be handled that way since it simplifies a lot.
OOP : Just Code Organization
OOP is just a way of organizing code though and that is what most of the world needs: code organization. Code organization (when done properly) allows maintenance to be done quickly and by a large number of people.
Data encapsulation (think hiding algorithms) allows more people who don't necessarily understand the ugly innards of the algo itself to still do maintenance fixes since code is organized into components that work properly as black boxes.
That's what I thought was nice about the MFC wrapper. It organized some things that I didn't want to know how they worked so I could put them together in ways to build something.
Slow Down & Write K&R C
If only we all had the time to slow down and write programs like the K&R C book. But we don't. Things must be hidden and hidden means there will be things I don't understand. Not my first choice but I have to build a product.
I hope you'll write up an article on FSMs. It would be a great read.
Yeah, someone had kind of already pointed that out, but that doesn't seem to be the problem.
I went back and checked the Visual Studio Installer and it shows that I picked the option for MFC: https://i.stack.imgur.com/CBHX4.png[^]
Show me how to get to the project template please. Grab a screen shot and post.
if you need an easy way to post the screen shot.
1) go to Electrical Engineering Stack Exchange[^]
2) open any question
3) paste the image into an answer and it will create an imgur link for you.
4) grab the imgur link and post here
You don't have to save your answer -- it's just an easy way to get an imgur link
Open the Visual Studio Installer
For Visual Studio 2019 Preview, click "Update"
Click "Individual Components"
Scroll all the way down
About 8 lines up is "Visual C++ MFC for x86 and x64"
Make sure it's selected (it does NOT automatically select)
Also select "Windows Universal C Runtime" (at the bottom)