Paul West

Junilu,

Elegance is a good word.  In the field I would usually say ``make it easy''.  Yes, it is cool you got something really complicated to start working, but please make it easy to use.  IE, I don't mind creating an object with your setup and then calling a function.  While you are at it,  make the names obvious!

Also, sorry if I have missed your emails, my email filter is strange...

Thanks,

~Paul

Junilu Lacar wrote:
This past fall, my wife and I went down to the University of Cincinnati with our daughter for a college visit. One of the things we really liked about UC was their co-op program, where students in certain programs like engineering, computer science, and business are required to spend entire school terms working in the industry, not as unpaid interns but as paid full-time employees. Their mandatory co-op rotations start in their second year. This is just one of many ways a better alignment between education and industry can be achieved but much more could be done in schools during those critical first and second years to give students a better foundation that can make their co-op experiences even more beneficial and rewarding. This is one of the articles I found yesterday: https://arxiv.org/pdf/0908.4353.pdf -- it lists a number of recommendations that I think are worth considering and discussing.

The other document I found was this: http://dl.acm.org/citation.cfm?id=800626 - I haven't read through the whole paper but I did find a preview that included this in its abstract ...

Some of those things we have implemented (Industry Advisor Board).  Probably the most significant issue is deciding when to adopt the next technology, drop an old one, or don't do anything.  I've noticed, and hopefully y'all have as well, technologies will come and then wane:  Perl, Struts, Objective-C.  Now these are still used, but they may not be the best focus of technology.  Right now AWS ("the cloud"), and javascript (node.js and angular) are pretty hot right now.  How do I know what will stick?  Perl seemed like it was taking off at first...

It would be good to focus on the principles behind these technologies and leave the language/syntax to whatever is big at the time...

Liutauras Vilda wrote:

Paul West wrote:I have tried to add some (like Git), but there is definitely room for improvement.  

But this is something shouldn't be a one session thing I believe, it supposed to be an ongoing on daily basis...

I agree!  In my classes ALL assignments are submitted through Github.  The course contents (slides, class code, etc..) is stored on Github.  I would run everything on Github if I could find an *easy* way to store grades and run timed exams.  I try to avoid the Blackboard.

~Paul

Junilu Lacar wrote:I got another email back from the faculty committee chair. I'm getting a sense that while he says they are open to discussion, they aren't very keen on the idea of changing their curriculum.

...we are in the middle of preparations for a major activity that will not finish until possibly the middle of 2018. And, of course, any changes in content of courses or the program is a fairly long process and requires extensive consultation among faculty and students to ensure that there are no unintended consequences.

I will try to keep at them but it's starting to look like I'm going to eventually end up in a dead end with these guys.

Sounds like a large University and/or public school.  Keep in mind change at a lot of these places is very slow...

Junilu Lacar wrote:
@Paul, I'm starting to think it might be better to continue this conversation with you instead. Since you seem to be already on board with the idea of improving alignment between academia and industry, why don't we explore some ways we can get a more collaborative effort between the two sides going?

You have actually caught us at a good time.  Last year the University put forth a a vision for the next 10 years.  One of the key points was called ELI (Experiential Learning Initiative.)   Basically, they (President/VPs/Deans) want to see more partners with industry bringing experience into the classroom.  I have tried to add some (like Git), but there is definitely room for improvement.  

I talked to our chair, we do have some classes for ELI: an internship and teamwork class.  The internship is basically, the student works in industry and then gets classroom credit (after submitting a paper describing the work.)  I'm vague on the teamwork one, so I'll have to get more information there.

The University has an Industry Advisory Board (IAB) that allows industry partners to meet and discuss what should be added/removed from the classroom.  Depending on what you qualifications, I might be able to add you to it.

Anyways, send me me ideas!  I'll try to get to those papers today after class...

~Paul

Campbell Ritchie wrote:Yes, that is a pretty dreadful assignment. Had the assignment said,

Write a noughts and crosses game, expecting basic output like this:-
  |X|  
O|X|  
  |O|
Additional marks may be given for better functionality or display.

...that would have been a good assignment. The prescriptiveness stops the students thinking about the problem and forces them to use inelegant solutions.

Agreed!

Junilu Lacar wrote:Whatever reasons there may be for lowering expectations, I just can't see any sane justification for giving programming exercises like this: https://coderanch.com/forums/posts/preList/675232/3162242#3162242

Wow, it is hard for me to know where to begin.  I mean, I see what the teacher is trying to do, but think he/she went overboard on constraining the problem!  Why are there so many statics!?

Maybe this is a starting problem and the teacher is trying to keep it simple...  Ya, I don't know.

I think Campbell touches on a very good point.  There are students in my class that I know are not going to do well in the field.  Luckily, I teach at a private University so I am free to come up to the student and talk about how Computer Science *may* not be the right career path for them.  Also, I'm able to setup homework/tests to show students what they need to do in order to succeed in a Software Engineering career.

Unfortunately, I believe a good number of public college/university have a difficult time with dissuading students from certain career paths.  I have taught at a public college and I've talked to some professors from others.  There is a push to meet a graduation quota which essentially drives a "lower bar" for classes.  It also dissuades professors form have "the talk" as well.  This is coupled with the fact that the US is in short supply of programmers has only made the situation worse.

Sadly, I have no solution to this problem because there is so much money in the University system.  =(

Junilu -- So a University asked for academic papers showing why academia is disconnected from reality?  ba dum ching!  In seriousness, I'm glad someone has at least attempted to show the problem.

That makes sense, and I agree that there is a severe lack of context for students here.  A root cause is that students haven't had to deal with working in the field.  My current solution is to have them do a group project, plead with them to do proper requirements, design, testing, and coding style.  After they don't, watch the ship sink, then have the "coming to Jesus" moment after their presentation.  While this trial by fire method takes the entire semester, I've had good feedback afterwards (although the students despise it during the semester.)  Some of the things they seem to learn:  students realize how to deal with slackers, why you need to test your interfaces thoroughly, why simple interfaces are a good thing, why you should not mind asking others for help, and repositories are a good thing.

While I wish there was a simpler solution, I'm starting to believe that the students just need to go through the pain.

So a quick top 5 off the top of my head:
1) Team Experience (see above)
2) Abstraction: It takes students awhile to how simplify their thinking improves productivity.
3) Public/Contract: It takes students awhile to realize that anything will be sent to their public methods.  I make my test cases pure evil.  Public/Contract should be simple, yet powerful enough to fulfill the requirements.
4) Refactoring:  Most student seem to believe it is best to just rewrite the entire thing.  There are numerous was to refactor code.  Hopefully I'll have time this semester to go through them.
5) Testing: This goes with #3, but more of a your test cases are part of your code.  IE: we need to be able to measure the quality of your code as well as the code submitted.

Thanks Junilu on staying on this, I'm interested to see what come out!

I agree with you on the Compose method--it is a simple (beginner) process to improve readability with minimal overhead.

Hi Junilu,

Refactoring is not too advance for my class.  What I stated was that the book Refactoring to Patterns would be too much of a jump to use solely for my class.  The issue I'm having is finding a good book to bridge from I-have-no-idea-what-an-object-is-and-I'm-a-terrible-coder to refactoring.  From your example, I'm always amazed how confusing "private boolean bouncesRight()" is to my students...  Private!?  Boolean!? rand.something!?  You would be amazed how many times I see students type Random.nextInt() and they look at me like it should work perfectly! >.<

I know how some other Java classes are taught which lead to a lot of How and leave out Why/What.  Please understand that my students seem to grasp Why/What fairly well.  I have finished grading the midterm and they did well (80%+) on the SOLID portion which required them to read code, identify why the code was poor (smells) and then stub out a solution.  What they did less well on was following the iterations of a for loop.  Yes, literally they knew how to apply LSP, but failed on how many iterations are in a simple two variable for loop.  (!!!)

~Paul

I received the Refactoring to Patterns book and I do like it, but I think it is too high level for the beginning of the OOP course.  Right now students need to understand OOP/OOD basics.  Afterwards, later in the course, I believe some of the ideas from Refactoring to Patterns would be very helpful--thanks!  

I looked around and got a hold of "The Object-Oriented Thought Process" (TOOTP), and I'm liking it so far (haven't finished reading it yet.)  My main concern is the focus on theory instead of practice--the students need lots of concrete examples.  The TOOTP book provides some good examples, but I believe they need more of how to write the Java syntax (the book does not cover Java syntax extensively.)  In other words, I believe the students would get the semantics, but be lost on the syntax (a common problem in my courses.)  I'm debating on letting them "use the Internet" or sticking with a second book to fill in the need.  Do you have any suggestions, the search has become extremely monotonous...

Currently I'm looking at http://www.tutorialspoint.com/java/java_tutorial.pdf and have requested a copy of "Core Java Volume I--Fundamentals" to fill in the practical need.

Thanks again for all the help,

~Paul

Piet Souris wrote:What I'm missing sofar: what kind of students are we talking about?

These are college students in their second or third semester of Computer Science at an accredited 4-year private University.  They have gone through a basic Procedural Programming course (no Objects) so they understand basic data types, control structures, functions, and divide-n-conquer.  Most are Computer Science majors, but some are minoring.  Most that minor are in Graphic Design.

Most students (majors and minors) are taking a networking class along with this one.

Junilu Lacar wrote:I'm a big fan of refactoring to patterns instead of starting off with a pattern in mind. I'm also a big fan of simplicity, hence, I often make references to the 4 Rules of Simple Design. Patterns evolved out of instances. Someone had a problem, they solved it a certain way. Someone else had a similar problem, and they came up with a similar solution. After a third time, somebody said, "Hey, there's a common theme here..." and then the pattern was given a name, defined, and publicized. It seems logical to me to have students go through that same process of discovery and recognition, rather than telling them, here's what you want to do, and this is the pattern that you want to use to do it.  That gives them only the end goal and the solution, leaving out the most important thing, IMO, about patterns: the context in which a problem can be solved by applying a pattern. And I don't buy an argument that says, "Well, the problem is 'How do we achieve this goal?'" It's not, and if you think it is, then I don't think you understand enough about patterns.

I looked at the TOC for Refactoring to Patterns and it looked good, so I requested my free exam copy -- a perk of academia.  I have considered using Design Patterns as my book, but that is a little advance for the students.

I think a little history will help people understand my position right now.  When I started at the University, the course order was [Alice or VB] -> C++ -> Java I -> Data Structures (C++).  In other words, it was very language focused, which I wanted to change.  I put in a request to change Intro to Computer Science to Procedural Programming and Java I to Object Oriented Programming.  Last week that got approved, so I'm in this transition period were the course is still "Java I", but I'm focusing more on OOP.  Right now, I'm trying to figure out the best way to setup the new course as all the old materials are heavily Java focused.  The current book is Java Foundations: Introduction to Program Design and Data Structures which does have some OOP, but focuses on Data Structures--an important subject covered in the next course.  If you have suggestions, please send along!

I get the feeling most people here would agree the change is for the better, although some would want to change the order.  BTW, Alice/VB courses are for people with no programming experience who want to get an idea of programming.  So, while Java/OOP is technically the third course, I generally say it is the second programming course.  (If you have ever done Alice before you will see why.)

Your example is a good start, especially for getting terminology down (which is hard at first.)  I just need a good source that can continue it throughout the course.  Aka, a textbook...

I agree students should design more.  There are some issues.  At my University and the ones I've attended, we take CS through practice.  We start with programming and then strap on concepts.  To that end we start with very contrived examples to further understanding.  Design is not something that is taught first, and therefore is ignored unless necessary.  That plus getting students to think first and then act is like pulling teeth.

If I had some good OOD questions for homework to accompany the programming assignments, I bet that would help student at least think first.  That and Junilu's link would probably help as well.

Ah, I was using intuitive to mean understanding not easy.  So, I was saying the intuition helps give you an understanding (reason) for something, not that it will come easily.  This is especially true for OOP which is easy to poorly engineer.  Most students understand the desire for objects after data types and functions have been taught.  This is a bottom up approach, and it sounds like you are advocating a top down.  Since I'm a systems programmer, I'm not surprised, but I'm interested as to why top-down is preferred/better here.

Now if the issue on this site is that students start with Java as their first programming language and work on procedural coding, then yes that is absolutely terrible.

To expand on Daniel's point of a BS in CS student's grasp of OOD, keep in mind that we aim to create generalists who can pick up on topics easily.  I'm not saying a student shouldn't know the basics (encapsulation, polymorphism via inheritance, separation of labor, etc..), but that trade-offs are made.  Example: Do you we teach advance Design Patterns or Caches?  Furthermore, all the Universities I've attended as a student and faculty have CS as a packed major.  In other words, we do not have enough time to cover everything.  American Universities have time constraints.

For my OOP class I've been slowly adding Design Patterns and other OO principles.  It would be great if there was a good list of questions about OOD.  Most I find are: write a class that does blah blah blah.  Instead, I'd prefer, Design a system that does blah blah adhering to <insert Desin Pattern/Paradigm here>.  The questions should have a grading rubric that helps me identify good student solutions and bad because there will be so many of each.