Re: Academic CS Losers?

Re: Academic CS Losers?

[Richard A. O'Keefe]

jmartin@kaiwan009.kaiwan.com (Jay M Martin) writes:
>If Computer Science can't get industry to donate code, then it time
>for Computer Science to do large projects themselves.

I keep telling people how very impressed I am by the Icon project.
Icon is an interesting programming language.  Arizona have a larger
installed user base than some commercial companies.  They have
ported Icon to a very wide range of architectures and operating
systems.  BUT to do something like this doesn't require just one
very smart professor (Griswold) and good students; it requires
a long-term commitment from the whole department and it requires
$money$ to pay for the hardware and clerical support.

I hope students who've worked on Icon are very much more employable;
they deserve to be.  But if you get calls from head-hunters saying
"have you got any students who can program Windows below the API level?
There's a lot of demand for that" (this really happened to me) it is
rather discouraging.

>Why is doing
>large important software project demonstrating clean software
>techniques so disparaged in CS?

_Is_ it disparaged in CS?  We'd do it like a shot if
(a) we could do it without kicking a whole lot of important things out
    of the curriculum (including technical writing) that _are_ there.
    We're constantly trying to improve our course, but there is just so
    much time in an undergraduate degree and there is _so_ much we need
    to teach. (Like spelling and arithmetic. It's not just the US schools.
    TV has had the same effects everywhere.)
(b) if it didn't frighten off potential students.  When we were just
    _thinking_ about switching from Pascal to another language in first
    year, we got phone calls from schools saying "do that and we'll tell
    our pupils to go to elsewhere".  I am not joking.  We've switched to
    Ada.  Great language.  But I hope we survive the change.
(c) the market for students who've done it were just a _bit_ bigger.
    Industry apathy isn't confined to the USA either.  (For what it's
    worth, some of the research projects some of our staff work on _are_
    clean commercial level software involving some graduate students.)

We've switched to Ada because we _are_ interested in producing students
who can write working code to spec (as well as understanding what they
are doing).  We'll consider _any_ suggestions to help achieve that goal.
What should we be doing?

>It
>seems to me reasonable to require 3-6 quarter classes (2-4 semester)
>of programming lab on a real project.  I think the students would
>learn alot.  Empirical studies could be done with these labs.  
>Please tell me why this is not being done (I know there has got
>to be a reason).

There aren't 2-4 semesters spare.  What do we kick out to make room?
That's our problem.  We're not teaching rocket science either.
(Big-Oh is not rocket science.  It is very very practical.  Basically,
it puts some detail on the motto "beware of solving toy problems".)

>Why can't Computer Science answer the real questions like which
>approach to software construction are optimal given which
>circumstances?   Fundamental questions like: Should programming
>languages be more controlled/disciplined or more free/powerful?

Questions about programming languages have a lot to do with psychology.
Since people and problems differ, I'm afraid the answer is
"sometimes they should and sometimes they shouldn't; it depends".
Besides, where is it written that more controlled is the opposite of
more powerful?  Ada is _both_ more discplined _and_ more powerful than C.

Again, software construction is mathematical, social, political, legal,
and psychological as well as computational.  Some academics _are_ trying
to tackle these issues (not me).  See for example the work on
meta-modelling.  A student here is working on meta-modelling of OOD.
It's important.  It's hard.

>If
>academia actually cared about teaching the latest software methods,
>then I believe Ada would have immediately taken off at universities. 

As it happens, I learned about Ada at a University.  I friend and I 
were even going to post a comment in the first general review about
exceptions, but we found that someone else got there first.  This was
even before Ada 83.

>They would have been out front on OO technology instead of eating
>industry's dust.  

Where did SELF, Sather, Tethys, Emerald, and a lot of other good OOP
come from?  Industry?  Nope.

>Many years ago it seemed to me the academia was out
>in front,  now they have regressed to teaching C (talk about training).

In the 90s, universities have to earn a living.  When I was an undergraduate,
the NZ government paid me to study.  Nowadays that's a thing of the past.
NZ and Oz governments charge students, and not small sums.  Any student who
can do a bit of arithmetic says "hmm, I am going to spend $X for Y years,
instead of earning $Z.  I had better earn at least ($X+$Z)*Y more than
someone without a degree otherwise I will be losing money."  In my case,
even though my education was subsidised, the loss of income means that I
won't break even (compared with someone who gets a job hacking visual
basic) until I'm 50.  This means that there is a *very* strong pressure
from students "don't waste my time with things that won't directly help
me get a well paying job".  RMIT _has_ resisted the pressure to train 
people in C or C++ or whatever the fashion of the instant is (we do teach
them whereabouts in the course and to the degree that it makes sense),
but if we go _too_ far out in front it will ruin us.  Specifically:  we
run a very real risk of being perceived by students and industry as
"theoretical", "impractical", "out of touch" precisely *because* we have
switched to Ada.  If we spent a significant time on Eiffel,
bye-bye students, bye-bye income.

What it boils down to is that we can only afford to teach things that
industry is willing to reward students for having learned.

-- 
"The complex-type shall be a simple-type."  ISO 10206:1991 (Extended Pascal)
Richard A. O'Keefe; http://www.cs.rmit.edu.au/~ok; RMIT Comp.Sci.

Re: Should internet support software be written in Ada?

[Bill Brooks]

In article <2F5B780E@SMTPGATE2.STRATCOM.AF.MIL>,
Bennett, Chip (KTR) ~U <BennettC@J64.STRATCOM.AF.MIL> wrote:
>  [...stuff deleted..]
>
>Point 2:  I going to make a huge leap here and assume that httpd is written
>in C.  [...stuff deleted..]
> Comments?
>
>Chip Bennett

Yep. Here's a representative sample of the code that comes with NCSA's
httpd (everything including the formatting is from the original):
----------------------- start paste --------------------------
     */
    if (strchr(mapname,'/')) {
      strcpy(conf,getenv("PATH_TRANSLATED"));
      goto openconf;
    }
    
    if ((fp = fopen(CONF_FILE, "r")) == NULL)
        servererr(strcat("Couldn't open configuration file:", CONF_FILE));

    while(!(getline(input,MAXLINE,fp))) {
        char confname[MAXLINE];
        if((input[0] == '#') || (!input[0]))
            continue;
        for(i=0;isname(input[i]) && (input[i] != ':');i++)
            confname[i] = input[i];
        confname[i] = '\0';
        if(!strcmp(confname,mapname))
            goto found;
     }
-----------------------  end paste  ---------------------------
In the rich tradition of discussing good software engineering practices in
c.l.a(regardless of language) I'll ask: is this good coding style?
Keep in mind that this code was written under the auspices of one of
the top 5 schools in CS in the United States.



-- 
"Bright young men of disheveled appearance, often with sunken glowing
eyes...their fingers, already poised to strike, at the buttons and
keys on which their attention seems to be riveted as a gambler's on
the rolling dice."  -Joseph Weizenbaum on "compulsive programmers"

Re: Academic CS Losers?

[Phillip Fanous]

: (Since everyone laughs at making new languages or user interfaces
: based on parsing, why should Compilers be a required course?

For me, it was one of the more enlightening courses in my CS program.  The
book was pathetic, but the instructor was quite effective. Also, the main
portion of the grade was based upon the implementation of a "baby C"
compiler. For one thing, I gained a much deeper understanding of the C
language (understanding the recursive nature of compiler functionality
actually made looking at what I once thought was an obscure program not so
obscure.)

:    181   Formal languages and Automata Theory (Kill)  

I agree. That class is completely useless. 


: physics. We don't need to do combinatorial logic maps etc.  We do not
: really need to understand the details of hardware or worry about
: "micro-coding" which is obsolete. Assembly coverage also should be
: light. Instead we need to look at an architecture from a higher
: level.  "Arch I" should cover something like Tanenbaum Structured
: Computer Org and "Arch II" should cover Patterson and Hennessy (now
: used at graduate level).  We sure don't need software people
: doing "Radio Shack" projects in a lab. Networks is probably too
: specific a topic to force at the undergrad level).

I know this is probably geared more toward comp eng but what about 
embedded systems programming? It can't be that bad giving SW people an 
intro into the field of microprocessor HW/SW design. Granted, This field 
also requires a detailed understanding of electric circuits.




: My opinion that lower division programming language should be done in
: a done in a strongly typed imperitive object oriented language which
: is very disiplined.   Examples: Ada9x, Modula3, Oberon2.  More
: crackpot functional (Scheme/Lisp) and declaritive languages (Prolog)
: would be covered in later programming languages classes.  I am not
: impressed with my department's current choices in programming
: languages.

I agree. This would make learning C++ much easier and would help the 
novice programmer in adopting the object-oriented design paradigm early 
so that they can develop good design habits.

Re: Academic CS Losers?

[Bill Winn]

In article <3n5410$pv1@crl.crl.com>, pfanous@crl.com writes...
>: My opinion that lower division programming language should be done in
>: a done in a strongly typed imperitive object oriented language which
>: is very disiplined.   Examples: Ada9x, Modula3, Oberon2.  More
>I agree. This would make learning C++ much easier and would help the 
>novice programmer in adopting the object-oriented design paradigm early 
>so that they can develop good design habits.
>
If the teaching of the Object paradigm is important, I believe teaching 
Smalltalk does better job than any of the aforementioned languages.  
Smalltalk does not allow one to fall out of the Object paradigm; hybrid 
languages allow one to use the Structured or (in some cases) the Hacking 
paradigms.

I do, however, advocate the teaching of a strongly-typed language (e.g. 
Ada95) to students before unleashing C++ upon them.


Bill Winn
Software Engineer - Analysts International Corporation
-------------------------------
wjwinn@kocrsv01.delcoelect.com
wwinn@klingon.iupucs.iupui.edu

My views do not express the views of anyone except my alter-ego.