Resolve C++

Resolve C++ is the official programming language of The Ohio State University CIS department. It's key "features" include:

• Almost a dozen keywords (object, preserves, consumes, ...) that have been #define'd to a blank space.
• All C++ data types (int, char, etc.) are illegal. Instead, you use classes called Integer, Character, etc.
• "Clear" naming conventions. There is actually a function called Least_Cost_Path_Machine_Kernel_1a_C_K::Get_First_Vertex_On_A_Least_Cost_Path()
• The assignment operator is essentially gone, having been replaced by swapping references.
• A separate 'abstract_description' that is essentially meaningless, but must be included anyway.
• An excessive reliance on templates. Combined with the above, any time you want to use an object, it requires no fewer than 4 extra files.
• "Formal Comments" - Code that is meaningless
• A 'mathematical specification language' that is actually harder to understand than code.

Overall, it is exactly the sort of thing that the designers of C and C++ were hoping to avoid.

It should be noted that Resolve C++ is for introductory students, and The Ohio State University understands that nobody will use Resolve outside of CIS 221, 222 & 321. The university is teaching programming discipline through this modification of C++.

That aside, the node on The Ohio State University refers to Resolve as like C or C++, but completely anal.

It should also be noted that Jaggar "analysis" of Resolve/C++ is not well supported. The CIS department is well aware that no one will use Resolve/C++ outside of the three course sequence as rmohr stated. They are also aware that the students that complain the most about the sequence are those that don't fully understand what they are trying to teach you. Most "thank you"s they receive from students come after those students graduate and realize that it was important they knew the material that the course sequence covered. It's all about software development. Now on to Jaggar "points".

1."Almost a dozen keywords (object, preserves, consumes, ...) that have been #define'd to a blank space."
These keywords are used to document the code, making it easier to understand. They also serve to better describe the actions taking place. Microsoft is planning a release of C# that also has keywords similar to these.

2."All C++ data types (int, char, etc.) are illegal. Instead, you use classes called Integer, Character, etc. "
If you look into the component catalog and see the implementation of several components you'll notice that many times we need to swap items of unknown type. All the Resolve components have swap operations but the int, char, double, ect. do not have this functionality. So the code wouldn't work if you used these primitive types. So obviously they created classes for each type that would support that functionality.

3.""Clear" naming conventions. There is actually a function called Least_Cost_Path_Machine_Kernel_1a_C_K::Get_First_Vertex_On_A_Least_Cost_Path() "
Yes I agree that the names are long, but they are also descriptive and self documenting. Also it is much easier to find things in various directories when you know that to go from the abstract component to the concrete component you only have to change two characters.

4."The assignment operator is essentially gone, having been replaced by swapping references."
This is done to avoid the expense of copying a large data type, such as a Sequence_Of_Queue_Of_Integers for example. Deep copy of such a large data type might even be a O(n^2) operation or greater. While the Swap operation runs in constant time, every time. Considering how often we need to assign/swap objects this was a very good design choice that exists in many other libraries.

5."A separate 'abstract_description' that is essentially meaningless, but must be included anyway."
It may take time to write an abstract_description but when programming in C++ most developers create a similar file anyway, one that outlines all the operations and them implement those operations somewhere else. The requires/ensures clause that are included in those files are similar to the precondition/post condition you would have to write in professional industry anyway. The abstract component is also a great way to document your code because it provides all the information about a component that you would ever need to use it, which is more than I can say about most C++ components. And once you learn how to read the mathematical descriptions it is actually easier to read them then to have someone tell you how to use the operation.

6."An excessive reliance on templates. Combined with the above, any time you want to use an object, it requires no fewer than 4 extra files."
The "excessive" reliance on templates is used to give the user of any component the most flexibility and control as possible. Most components have default parameters which bring them down to only one or two mandatory templates parameters. That is very typical of most components. Also 4 files is an exaggeration.

7.""Formal Comments" - Code that is meaningless "
Those comments are used to describe the functionality of the code. They are the documentation of each component which is very important in software development, i.e. not meaningless.

8."A 'mathmetical specification language' that is actually harder to understand than code."
It isn't harder to understand than code if you actually understand any formal mathematics whatsoever. Computer Science has a lot of math involved, mathematics should be an integral part of any computer science curriculum. And this language says what it needs to say in much fewer words than it would take to actually write out anything it might need to describe.

Overall it is an expertly designed programming paradigm created by professionals. You are not intended to use it in the real world and the designers are aware of that. You are intended to use the methodology to create good software and apply what you learned to other languages. Don't get me wrong, I'm an avid C++ programmer, but considering Java and C# follow this programming style more closely than C/C++ and that Java/C# are supposed to be improvements on C/C++ then I would say perhaps what the original designers had in mind wasn't the best idea. They provided us with a lot of flexibility in C/C++ which is what makes them great languages, but they are also very unsafe languages.

ComputerAnalysis is correct in most of his points, however, it must also be noted that the RESOLVE/C++ sequence is administered to freshman CSE students who may only have had a single programming class, which may not have even been college-level.

This sequence then attempts to teach data structures, component-based programming, more specifically in the RESOLVE discipline, some of the theory behind those, all in a language nobody has seen before. While the idea of this is fine in theory, in practice you have students who never get over the quirks of the language itself in order to learn what they are supposed to learn.

Then they take classes where they are required to make substantial programs, and they don't know a real programming language (which is not necessarily the fault of the RESOLVE series as perhaps there could just be another requirement for those classes).

Also, from a practical standpoint, not even in the world, just in the class, the method and class names are *way* too long. I appreciate that they are consistent, but they do not have to take up most of a line. It makes code *harder* to read when something should be on one line and it is on 3.

The use of templates does offer a lot of flexibility, but what it also does is gives a page of almost completely indecipherable errors whenever there is a slight issue in the code. This confuses students, to say the least.

Hi there! I'm an instructor with OSU's CSE department.  Let me see if I can clarify some things.

The "Resolve" language isn't actually what students at OSU use.  It's a language used for research purposes that undergrads never actually see (it looks quite different from what they use).  Until Summer 2012, when we switch to Java, students use something called Resolve/C++, which is really just C++ with a bunch of stuff added onto it.   The primary purpose of this extra "stuff" is to protect students from pointer errors, while still allowing them to manipulate objects without copying.   This allows us to teach them complicated concepts (like client-based binary search tree algorithms that involve a tree object swapping itself with a subtree) without exposing them to aliasing and dereferencing errors.  The utility of this approach is it greatly speeds up how fast we can teach them these sorts of concepts, until we're ready to actually get to pointers and linked lists.

The use of Resolve/C++ will disappear in a few months to be replaced by a Java series, which is the right thing to do, but it's not without a downside.   In Java, all objects (other than primitive values) are accessed through implicit smart pointers Java calls "references", so aliasing is a constant issue as it breaks encapsulation: imagine a client of a value-based map interface adding (foo, bar) to a map, then changing foo without realizing it: if it becomes a duplicate key, it could break all the operations of the map.   The implementer of the map can't prevent this eventuality in Java.  Additionally, in Java the only parameter that can be passed by reference is the distinguished parameter, so implementing a tree that allows this to swap with this.subtree requires enclosing the parameter inside a separate object, which is ugly, or else writing additional code to support item encapsulation within the tree interface.  So it's far from ideal, but it still needs to happen.

The upside is that students will be learning using a language they can experiment with on their own at home, which is to be encouraged.  As for how useful this is in principle, that's an open question.  OSU's CSE program is both controversial and award-winning.  Employers snap up students with BS in CSE and CIS from this college very rapidly, and they earn much more than people who get "applied" degrees at technical schools, even though OSU students don't come out of the program knowing all the tricks of C++ or Java or MSVS.  That's because needed skills in language and software change very rapidly, and how long do you think the languages of today will be useful, anyway?  Anyone with a strong theoretical background (such as an OSU BS degree) will be able to learn what they need to know on the job.  This is why employers choose them, and I feel the course as it currently is more than adequately prepares them, though some of the syntax is a bit annoying.  (Though apart from some wordy operation names, virtually the only thing students have to type in the labs that isn't standard C++ is the word "object" which is used before stack-based variables.)