Computer Science Teacher
Computer Science Teacher - Thoughts and Information from Alfred Thompson

October, 2006

  • Computer Science Teacher - Thoughts and Information from Alfred Thompson

    A Reply to an Interesting Comment - More on a first programming language


    Tom Hoffman wrote a long and very interesting reply to my previous post for which I am very grateful. He makes some thought provoking statements and I like having my thought provoked. I was going to reply in an additional comment but things got really long so I decided that a new post (this one) was in order.

    The short version though is that Tom doesn't make a good case as to why a language being non-proprietary is relevant. For example, I think that if a person says "I want to give my students a copy of the software to use at home" that is relevant. That has absolutely nothing to do with the language being proprietary or not. Tom talks about different things that are relevant but does not make a good case that these issues are the property only of non-proprietary tools. He also doesn't make a good case for why proprietary or commercial tools are "bad" or should be avoided.

    Further I would add that automatically ruling commercial software out just because it is proprietary or commercial is closed-minded, short sighted and intellectually indefensible. Teachers should be judging a product on how well it does the job not on who produces it.

    Tom's comments are in italics below. My replies are inline following Tom's comments.

    First off, there is nothing wrong with an educator using free software for philosophical reasons.  Teachers often make decisions for philosophical reasons.  I'd be frightened to trust my kid with someone who didn't.

    Well it depends. How would you feel about a teacher who refused to teach about George Washington because the man was a slave owner? Valid philosophical reason or not? I think that the philosophy used should revolve around how well a tool teaches concepts rather than around the source of the tool.

    Now, what do you get with a free software license?

    1) the freedom to use the language for any purpose.

    For schools, the most important part here may be that this right doesn't expire.  You don't have to renew the license, you can't be forced into paying for an upgrade.  This isn't a limited educational version, you can use it to write and deploy any kind of application you want.  

    This is not something that non-proprietary software has a lock on. I don't know very many licensees that expire. The license for Visual Studio does not expire. And the academic version is the professional version with a different label on the box. Hardly limited. The difference is in the license which does not allow commercial development. That does not limit students in a first programming course in any real way. If fact any commercially viable software would easily generate enough income to buy a commercial license.

    2) the freedom to study how the language works and adapt it to your needs.

    Is this of practical value to 90% of the kids in an intro class?  Probably not.  Is it of value to teachers who really want to understand what they're teaching and kids who are fired up about programming?  I think it is.  Good programmers learn a lot by reading well written code.  You can read and learn from code that would be too complex for you to write, or understand completely.

    If by how the language works you mean looking at the source code for the compiler, I would argue that this is of use to fewer than 1% of the total population of people who have ever programmed in the history of programming. Of practical value to a single student in a first programming course? I don't think so. You can understand quite a bit about how a language works without having access to the source. Should the student know more than what is being covered in the first programming course? Of course, but that will be something they learn during their training and not something they will require in a teaching tool.

    But beyond that, yeah, this is a philosophical issue.  I believe that computer science is a science, and I can't imagine being in another science class, like biology or physics, where a student would be told, say, "Well, as a matter of fact, mitochondria do have their own RNA, but I can't tell you why, because that is a trade secret."  We should value engagement and drilling deeply into issues, without running into black boxes and proprietary code.

    You are addressing issues that are years away from a first programming course and outside the scope of my post. Interesting to be sure but a red herring in this discussion.

    3) the freedom to redistribute copies.

    This is very important for schools.  The language isn't limited to specific computers in the school.  It can be installed at home by students.  They can install it on their friends computers and show their friends how to program.

    You mean like Visual Studio .NET in the MSDN AA program, Visual Basic Express (free download) or the command line compilers that come free as part of newer Windows installs or updates though Windows Update? I don't see the connection to open source.

    4) the freedom to improve the program, and to redistribute your changes.

    Maybe not a big deal on the local level, but globally, it means that derivatives can be created that may suit local or educational needs better than the generic version.

    You do understand that you are making an argument against using Java and for using C# right? There are several C# compilers available in source form and one can easily make ones own modifications to the language without fear of legal action. The same is not true of Java which is a proprietary language and which Sun has taken people to court and won hundreds of millions of dollars in judgements against a company for making changes they didn't like.

    I'd like to address this on several fronts. First off it seems irrelevant to a first programming course. Neither students or teachers are going to be modifying compilers in that course. Secondly I don't see a whole lot of need for modifying compilers or IDEs by non-professionals. In fact few professionals are up to doing major modifications to compilers and IDEs. Even when they are I think that too many derivatives can cause software to be less productive as a teaching/learning tool because of a lack of consistency. It also makes finding comparable textbooks problematic. Further more it can make sharing of sample code and projects difficult which can limit what teachers can use in class.

    The may be some value in source availability for established professional developers but a) I don't see it for beginners and b) I don't see many professionals taking advantage of it either.

    Also, cross-platform compatibility does not always accompany free software, but it often does, and it is important for keeping schools' options open for their OS platform, and it ensures that students can use the software at home.

    The idea of cross-platform comparability does have merit. At the same time I think that in general the costs of maintaining multiple OS platforms in a single school (I have some experience in this from previously working in schools) adds costs and complexity that is hard to justify. Running Macs for graphic arts program makes some sense even though the rest of the building is Windows for example. However maintaining two platforms for teaching the same subjects is generally not a good idea. That's just my opinion based on my own experience in previous jobs in a couple of schools.

    FWIW The nice thing about a fast Internet connection is that schools can offer Virtual Terminal Access to a development platform at school for students to access from home on any platform. That is not used nearly as often as I think it could be or should be.

  • Computer Science Teacher - Thoughts and Information from Alfred Thompson

    Picking the First Programming Language


    A recurring question in computer science education at all levels is what language should be taught first. The discussions on this issue at Slashdot, where the issue comes up about once a year as far as I can tell, are legendary. There are various arguments that are used:

    • It should be a language used in industry so students can get jobs
    • It should not be a language used in industry - we're not a trade school
    • It should be a language that was developed specifically developed for teaching
    • It should be a very high level language
    • It should be a very low level language (assembly language
    • It should not be a proprietary language
    • It should be available on a lot of platforms
    • It should be available from multiple sources
    • and on and on and on

    It seems to me that the first thing one has to do in order to make a good selection is to remove the irrelevant arguments from the issue. For example, a language being used or not used in the professional job market is not in and of itself relevant. In a first course one is not trying to create a professional programmer (even though some have gotten jobs with little to no formal training) so the fact that a language is used for professional work in not important. Likewise that a language is used by professionals is not per se a reason to discard it. Now there may very well be things that make a language a good choice for professionals that either do not contribute to learning in a first course or even make it to complicated to use. But that the simple fact that professionals use the language does not automatically mean it is not good as a teaching language.

    Another completely irrelevant argument is over avoiding proprietary languages. Cost may (though it rarely is) an issue but generally schools can easily afford proprietary languages. Compilers and even IDEs are available for free for proprietary languages like Java and Visual Basic .NET. Often when I hear the argument that proprietary languages should not be used the issue is mostly philosophical and very often another way of saying "Microsoft Bad." Individuals who reject C# (which is not proprietary as the term is properly used) and promote Java (which is proprietary) by saying that they don't want to use proprietary languages generally fall into the "Anything but Microsoft" camp and are often confused about what is and is not a proprietary language anyway.

    A semi-relevant argument is the one about tools being available from multiple sources. But to be honest I think that is more valid in later courses  than in a first course. In a first course keeping it simple is important. I think that this is easier if every student is using the same tools as the ones being used by the instructor in class. Being available from multiple sources is a relevant argument for a lot of things but not for a first course in programming.

    The next big thing is to identify what things are relevant. In my opinion what is relevant are the things (features and tools) that help one teach the important concepts of the course. If for example object orientation is important than languages like FORTRAN, COBOL and PASCAL are not good candidates even though there are some versions of those languages that support OOP they are not really designed for it like C#, Java or Visual Basic .NET. If you are trying to teach strictly functional programming than something like Scheme is going to jump out as a natural choice while Java or C is clearly going to get ruled out pretty much automatically. I could go on about this but you probably get the idea.

    Things like how simple is the syntax, how easy to use is the debugger, how good are the error messages and related things are also relevant. Although to some the issue of using or not using a debugger is a source of major controversy. I may take that one up in a later post. But if you are going to use and IDE it's available features are relevant.

    So it is a complex question with no simple answers. A lot of times the instructors level of expertise with given languages is also going to be a factor. It's hard for me to second guess the choices someone else makes unless they are clearly failing at teaching or getting the students to learn. Of course lots of second guessing does go on. There is as much politics in computer science as anything else. It makes life interesting. Yeah, I think interesting is the word I want.

    BTW I read an interesting post today that is related to this topic. It was at Lance Fortnow's blog. The comments are the best part so don't miss them.


  • Computer Science Teacher - Thoughts and Information from Alfred Thompson

    Interesting links - Women in Computing & Computational Thinking


    Diane and Hilary (two very talented young women I work with) continue their road trip through the mid-west and far west this week. They visited a number of colleges early last week and finished up at the Midwest Women in Computing Conference where they presented. Diane posted some resources for women in computing at her blog. Diane left of NCWIT (National Center for Women & Information Technology) which has a lot of resources and programs to help women in the IT field and to help women get into the field. They will both be at the Grace Hopper Celebration of Women in Computer Science later this week. There are resources out there for women (young and old) who are interested in computing fields. We need to make young women aware of them so they don't think they are alone in being interested in the field.

    BTW I love the pictures Diane has been posting of the blue peep who is traveling with them. Frankly I think it is an example of how people can make pictures of trips a bit more interesting. So check out the photo albums. Maybe some students will get some ideas from them for travel blogs or web pages of their own.

    I also ran into Philip Wadler's page (thanks to a link from Lambda the Ultimate Programming Languages weblog) where he is collecting links to Computational Thinking information. Most of his links I have seen (and linked to before) but one that I haven't seen before is called Computer Science 4 Fun (aka cs4fn : the fun side of Computer Science) and looks very interesting.

    Adam Barr has an interesting (fairly short) post on making bugs easier to find. Adam works at Microsoft where he teaches Microsoft developers to do their jobs better. He's also written a book on debugging programs. So his comments come from someone who knows what he is talking about. Most comptuer science classes don't discuss bug preventing, bug detection or software enginnering in general so this post is one I would receommend sending students to read. Ask them to evaluate what he is says and discuss it in class or in writing. The sooner they think about a systems approach to software development the better off they will be - in my not so humble opinion.

Page 1 of 9 (26 items) 12345»