Slashdot Mirror
Suggested Curriculum for 'Complex Websites' Class?
StudMuffin asks: "I teach graduate computer science courses at a Big 10 university to grad students, who have never programmed before and are studying Human-Computer Interaction or other Information Science specialties. These courses are usually their first dip into the programming pool, so we have tons to cover in three months. This fall, I have been asked to take over and redesign our 'Complex Website' course, which is getting a bit long in the tooth. This course has traditionally been about database backed websites with server-side scripting. My only requirements are that there be coverage of PHP and that we have basic instruction about persistence using a database (which must be MySQL). However, I believe that the nature of 'complex' websites has changed, with XHTML, CSS, Javascript, web services, and so on. Sites like Google Maps make the browser feel like a fat client and are making the web browser a true window onto enormous data sets, and take into consideration the MoRAS of small views on large worlds. What do Slashdot readers consider a reasonable curriculum would be for a redesigned course like this?"
There are so many buzzwords that *each* take weeks to learn that there must be a way to boil it down to core concepts. For example, SQL has always be there and useful, for example, and will probably be around long after all the object-oriented xml fashion show has ended.
The "take-away" from such a course from people who have never programmed will be "nothing". Keep it simple.
do people link to bloody pdf files?! and why do /. allow them to do it? jesus, if there's anything that's going to make your browser feel like a "fat client" then it's going to be a bleedin' PDF that has a fair shot at crashing your browser.
I'd strongly recommend Ruby-on-Rails in addition to or even instead of PHP. Although there is a lot of PHP out there, I can't think of a reason to use it for a new project if you knew both PHP and Ruby, or if you knew neither and had to learn one or the other.
And I can think of a few strong reason to use Ruby: tainting, true object orrientation, no overflows,..
--MarkusQ
Given the level of your school, I think you should introduce the students to some (semi-) formal methods of designing web sites beside introducing the technologies (DB, CSS, ...).
My suggestions are:
WebML and WebRatio
Additionally (shameless plug), you could introduce some special cases of web design such as the one described here and implemented here.
It sounds more like a course that will give students what they need to create and host their own vanity site.
Are there many "complex" sites implemented in PHP and MySQL?
I would walk the class through the planning, implementation, customization, and maintainence, of an existing PHP/MySQL CMS. PHPNuke, Mambo, and Drupal come to mind as good bases. The advantage to using an existing CMS as a platform is that students would be able to focus on adding additional custom functionality instead of the base which might involve concepts they should already be familiar with. Hacking existing code gives you a a good look at what the developers have done right and what the student might have done differently. Their assignments could involve building new modules that meet certain criteria, improving load times, and streamlining code. The modules could then be released into the CMS' community. The students won't be able to just make obvious improvements because most of those trivial improvements will have already been made by the exisitng community. It would be a great way to introduce (or further enhance) the students' appreciaton of OSS concepts as they apply to web development.
SEO Firefox Extension
PHP is a good language for certain tasks, bit it forces you to focust on all kinds of tedious minutia that could scare off newcomers to the field. The big thing for an introduction is to give people a feeling of success and the satisfaction of creating something that functions properly. Besides, developing web applications without a webapp framework is hell. Case in point - the number of horribly broken PHP "frameworks" floating around out there.
Only teach javascript if you can teach good, practical javascript, and especially, when not to use javascript.
When used well, it can enhance usability, but it shouldn't ever be used just for the sake of it.
Self-referential sigs do not a humourous poster make.
It's okay to spend 95% of the class using PHP, but be sure to include a discussion of how PHP compares to alternative technologies. Knowing how to use a technology can be equally important as knowing where the technology fits into the "big picture."
Explain things like:
Database Options
- MySQL (open source, usually free)
- Oracle (powerful, but expensive)
- SQL Server (buggy, less expensive)
Server Side Scripting- PHP
- Java Server Pages (Requires J2EE)
- Active Server Pages (Requires
.NET)
Server Side FrameworksRegardless of what language you choose you need to cover the concepts of design patterns, antipatterns and try to instill some architectural sensitivty - maintanability, data hiding, modularity, testability, flexibility etc. into your students. I have seen Way WAY W*A*Y too many php hacks obviously written by inexperienced self-taught web programmers that are just flatout nightmarish.
Be sure to emphasize the truth of the matter - most programming is maintaining existing code, and if you don't lay a decent foundation you are doomed to endless torment in spaghetti code hell.
First off, HTML. They need to learn the basics of the document tree, the meanings of various element types (note the difference between "tag", "element", "element type" and "attribute"). Emphasise that user-agents aren't just traditional browsers (e.g. aural browsers, search engine crawlers, greasemonkey scripts).
Next, CSS. They should learn how to apply CSS well, like staying away from presentational class names, using contextual selectors instead of putting ids and classes on everything, and still using the appropriate element types instead of turning everything into a div element.
Next, an overview of how the request->response->render->submit process works, with a brief overview of HTTP and caching.
Next, an overview of Javascript. They don't have to spend too long on this, just show them what's possible. If you go into depth, teach object detection rather than browser detection, graceful degradation, unobtrusive Javascript (google those terms if they are unfamiliar).
The server-side smarts will be the hardest bit if they aren't programmers. Not sure what to suggest here, I don't think there's anything you can do to smooth the learning curve out.
Various other things that don't fit anywhere else: title attributes for help, mouseovers (or rather, their CSS equivalent) for isntant feedback, tab order for keyboard input, read a few of Jakob Neilsen's Alertbox columns for the usability side of things, accessibility - remember you need to compensate for not only blindness but colour blindness, etc (don't skimp on the contrast!).
with HCI "experts" not knowing how to program. It all too often occurs that you have a quack expert insiting that the program/website do something from a usability prespective thats just not possible. Anyone who is specializing in HCI should have a strong background in programming and computer technology, ESPECIALLY at the graduate level.
What's the purpose of this class? The idea of "complex website" is not well defined.
.NET, LAMP, etc. for discussions about backend stuff.
I would think a discussion of complex websites would first start with a discussion of n-tier development... seperation of business tier from data tier and UI tier. Those are the issues that most web teams deal with at corporate levels.
Transaction management, state management... other issues like this with web development.
These are all concepts, not technologies. Certainly there are some technology directions for say UI, such as CSS or Javascript that need to be mentioned as examples. And you can bring up examples from J2EE,
Back when I was in ComSci my professors taught concepts, not technologies. I don't understand at all where you are coming from with your main requirements being you need to pimp PHP and mySQL.
Forget about code semantics, focus instead on application development theory and techniques, application frameworks, design patterns, etc.
I personally develop in both ColdFusion and PHP along with the Fusebox framework, and have just started using the fantastic FuseBuilder tool for the design stage. The using the Fusebox Lifecycle Process (FLiP) and a design tool that works with it (FuseBuilder) ensure that clients get what they want, no hassle, no "but it should be blue with green buttons". I can't promote FuseBuilder enough, it has become the bread and butter of both my day-job and side consulting.
Damien
I think any course on complex websites at a university level should focus more on best practices rather than a specific language or platform. Yes, use PHP and MySQL to teach the concepts, but make sure your course teaches concepts, not the language. I've worked with far too many people who "know" a language but have no idea of how to write a good web application. What they learn in this course should help them regardless of if they end up developing in PHP, .NET or Java.
Things to be sure to include:
A basic overview of the language; you can't escape doing this. Don't cover the basic syntax for variables, loops, etc. (they should be able to learn this stuff on their own) but its nuances and the way it approaches web development. Discuss the $_SESSION array and how it works in PHP, as well as the $_POST, $_REQUEST, $_GET and especially $_SERVER super variables. Mention how PHP turns a form element into an array if the html element has [] at the end of its name. If possible don't even bother with HTML, and I wouldn't worry too much about CSS either. Mention it briefly and explain why it's of benefit, but don't actually teach it. Often times a programmer won't even be the one writing HTML or CSS.
Good architecture: separation of code from content - especially in languages such as ASP and PHP. Discuss what works and what doesn't work for scalability. Bring up different architectures which are used and discuss the pros and cons of each. Potential things to cover in this section could be 3-tier architectures, front controllers, ORM frameworks, etc. You may also want to briefly mention different ways a web application may be scaled including techniques for load balancing and how this affects the design of web application.
Caching of output: far too many web sites and applications hit the database twenty times for a single page view. Hammer in the importance of caching, and introduce different techniques for doing so (full page caching, caching of specific database results, etc.)
Security issues: This is a major one. Proper escaping of input, session hijacking, cross-site scripting, etc. Be sure that people are educated on how easy it is to forge data that is submitted by get or post so they don't have URLs like view_billing_information.php?AcountID=512 where changing the URL allows you to view someone else's personal information. Yes this type of thing should be obvious but people don't always thing of it. Don't forget about cookies and the dangers of storing sensitive information in them.
Near the end of the course briefly cover things such as xml-http requests and SOAP but make the focus more of "these things exist" rather than detailed information on how to use them. Bring up JavaScript and client side code, but only after they have a solid grounding on the server-side of things.
Why not teach them about /. and more specifically SLASHcode? That has most of what you want, just have them create the site in PHP with mysql.
;)
I think by taking an example like this one, you'll end up with people that can make as complex as you need. Gods know, even Taco can't keep up with the code here anymore
firefox.exe weights in 39,856 Kb of memory on Windows (after openning a few tabs), sure feels like a fat client to me.
One word: Perl
I am no expert on complex website, but I do have a good suggestion:
If you're planning on teaching any programming, check out Python, it's very clean, clear, small and easy and has lot's of inroads into the subjects you want to treat.
Stuff like a functional SOAP Webservice can be done in under 10 lines of code. There's basic XML/HTML/CSS SQL too.
After introduction of the basic concept you can then continue with some PHP and MySQL.
Please try to learn them something about user interface design too. Stuff like avoiding "mistery meat navigation". Check out places like webpagesthatsuck for ideas.
RogerWilco the Adventurous Janitor
I'm a somehwat experienced developer specializing mostly in web related things. In the past year, I took two classes at Ohio State that are related to what you describe. One was a design class (think print design) using the web as the medium. The other was a usability class geared towards engineers (Industrial, Cognitive) which revolved largely around a data driven web project. The engineers all had taken some kind of freshman class where they wrote "hello world" in C.
My first bit of advice is that first time programmers/web site creators invariably tend to get mired in the technical details of implementing things. It becomes very hard to see the forest for the trees.
In the design class, students spent the majority of their time struggling with Dreamweaver/HTML/CSS. In the Usability course, they spent most of their time struggling with FrontPage/ASP/Access/HTML. If the focus of your course is HCI, it may be a mistake to be teaching web coding skills because this will detract from the true focus of the course. If the focus of your class is to give them web development skills, then you still may be better off looking at the big picture instead of getting mired in web implementation. If you are trying to give them web implementation skills, it may be better to give them structured fill-in-the-blanks homework assignments instead of an open ended project.
So moving on, if you're going to teach the programming skills, you want to make everything as simple as possible.
First off, consider not using MySQL. Instead, consider using MSDE and Access Data Projects (adp). MSDE is a free version of MS SQL server. The one big difference is that MSDE has a governor that prevents it from hosting high traffic databases. Access Data Projects (adp files) let you connect to an MSDE/MSSQL database using access as a front end. This is similar in principle to linked tables in access but it is much better. You can create msde tables and views in access while you can't do that with linked tables.
Using MSDE/ADP will make things much harder on you for setup, but much easier on the newbies. Here is the basic reasoning. People know access or if not they can figure it out via the stumble method. You can make and store somewhat complex queries as views without knowing SQL. An interface like phpmyadmin or even the new mysql query browser or the buggy admin interface is frightening in comparison.
For database access, don't teach them sql, mysql_connect style functions, or pear::Db. Instead, teach them DB_DataObject. DB_DataObject is the standard pear data access layer generator library based off of Pear:DB. You point it at a database (pretty much any kind) and it generates an extendable class for every table and view. All classes inherit the base object's methods like insert, update, and delete. It has a fairly simple yet modestly powerful search/query interface.
Why use DB_DataObject? It is much simpler than peardb/mysql_conect alternatives. You don't need to mess with connection strings. When combined with the capability to make views, you probably don't need to mess with any sql at all except in a few rare circumstances. The interface is consistent and it introduces them to valuable notions of a data access layer, object orient programming, the benefit of community libraries, etc.
Incidentally, there's some other libraries that plug DB_DataObject into HTML_QuickForms so that may have perks.
That brings up another point. Don't teach them anything involving html forms. Instead teach them HTML_QuickForms (another pear library). Again, the advantage here is that html_quickforms are waaaaay easier to understand and work with effectively than are plain html forms... especially when it comes to input validation. Of course, they are not very easy to format without using the Smarty template renderer and that opens a whole other can of worms (but you might want to teach templates anyway).
Anyways, I've just got done teaching a
First, as one poster pointed out, I would provide an overview of technologies out there (languages, databases, operating systems). The mantra of a good programmer is to use whatever tool is best for the job; so make sure they know what their choices are.
Second, maybe a brief discussion on hardware. Specifically different ways to assemble a server farm. Do you need one single machine, a db and a webserver, or thousands of servers all running in parallel. This would presumably cover load balancing, database replication, and all that good stuff.
Going hand in hand with hardware architechure, is the software architechure. So I would explain three tier architechure, and show them how to seperate DB Access, Business Logic, and Display Logic. Once again, reinforce the fact that there are numerous DB access libraries, and numerous templating solutions out there.
In a perfect world, I would want to teach next about design patterns, but because these students may not have the best handle on OOP, design patterns might be a stretch at this point. And depending on how much XHTML and CSS they have, this would be a good time to start looking at that too.
Since this is an intro programming class, start like you would start a programming lanugages class. Teach control structures, variable scoping, and then ease into OOP if you are so inclined.
If you skipped the design patterns before, this is a good time to bring them in, once the students have somewhat of a grasp on OOP. I would definitely reccomend the Factory pattern, since I've seen it in more than one instance in PEAR (DataObjects in particular).
Once they have these basics down, get them to write something easy... like an address book or something like that (typical stuff you would teach them in any intro CS class to reinforce this stuff).
Once they have all this stuff down, introduce them to a framework. It could be something that you develop as a class, or it could be something out there currently (cake, blueshoes, seagull, mojavi). Then have them take their previous application that they wrote and then integrate it into the framework. This would be a GREAT time to talk about reusable code, and a great time to introduce PEAR/PECL.
This might be a good time to have them work on a colabrative project (since that DOES happen in the real world). This would bring into the picture the concept of source control. Talk about CVS/SVN, and get them using it.
A good final project would be to take their original application that they wrapped in the framework, and then add in some AJAX goodies if they have a good enough handle on the JS. If not, something like JPSPAN or SAJAX might be a good tool to show them. I would reccomend simple AJAX goodies, like instantly saving form fields as they are typed in.
And don't make them fight with PHP4. Get them PHP5 to use! I've recently been going through PHP5 Power Programming, and I highly reccomend it for a good read on OOP and Design Patterns in PHP.
-Steve
If this is a class for 'Human Computer Interface' students, particularly students at the graduate level that have never programmed ... perhaps give a little thought to how they came to be graduate students in HCI that have never programmed.
Maybe it is because there is a world of difference between programming and human-computer interface design, just as there is a world of difference between chemical engineering and industrial structure painting. Paint is made of chemicals, but chemical engineers suck at painting houses - and although a light understanding of chemistry helps the painter, it doesn't take a chemical engineer to paint a wall.
Want to know what your focus should be, for developing a curriculum to describe to HCI students good complex web-site design? Crayons. And maybe a web browser to go look at web sites that suck and look at some good web sites in order to start the discussion about why some suck and why some are good. Have them map out the individual page interfaces in crayon and then have them draw the relationships between their pages and the environment (user, firewall, Internet in general, server farm, load balancer, database back end, other systems, etc.) in crayon. If they can't express and design human-computer interface concepts using a crayon, it isn't going to get expressed.
Even the best SQL mastery isn't going to help create a complex web site that feels 'natural' / isn't 'painful' to use, nor is PHP or Ruby or any other language. Those are implementation details, and if you wait until implementation to work through your complex user interface design decisions I can assure you : your web site will suck.
Graduate level studies are about theory, concepts, and developing an understanding for the underlying driving factors at the core behind the technology. If you have them coding in any language, hooking little web pages they hacked together with their new-found programming skills to a MySQL database then you have effectively robbed them of the very education you intended to provide.
Glonoinha the MebiByte Slayer
http://www.erasmatazz.com/library/Lilan/artists.ht ml
w o_Cultures_War.html
Not everyone holds the "role" argument.
http://www.erasmatazz.com/library/JCGD_Volume_8/T
"Manifested in the Western idea of "two different cultures".
It's not clear to me exactly what the requirements for this course are. Some more information about the context would be useful.
As a personal example, not long ago some colleagues and I reworked a reasonably complex web site (say 20-30 major pages with unique content and design, backed by a few hundred minor pages). The aim of the reworking was partly to improve the appearance and usability of the site, and partly to increase the range of content. Some of the bigger design/UI issues we touched on during the work were:
- usability (both the concept of studying user behaviour formally, and knowledge of existing research in this area)
- accessibility (always an under-rated issue, and never more important in web design than it is now there are anti-discrimination laws coming into effect)
- graphic design for the web (colour, alignment, etc. in the context of fluid layouts that will be displayed on-screen, and also web typography)
- navigation techniques (specific things like providing breadcrumbs for sites with a hierarchical structure, and more general concepts like designing good site maps and search functions).
and of course things like standards and browser compatibility issues.Obviously there's also a whole host of technologies involved; off the top of my head, we're using XML and XSLT combined with makefiles as a kind of GeekCMS, generating the XHTML that actually gets sent down the line with some CSS and occasional Javascript, along with CGI scripts written in Perl to access MySQL database stuff on a few of the pages and PHP to do similar things in other places. I'm not sure whether any of that, other than perhaps the existence of the various layers and the basic relationships between the technologies, is within the scope of the course here, though. If it's a post-grad course, give them a bibliography and some direction, and let them learn the different tools as they need them.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
I work as a PHP developer right now, working on the internal company website and several websites for customers. I did take some web classes in college, but there are things that they taught me that weren't useful and some things that I wish they had taught.
What They Didn't Tell Me But Should Have:
Design / Usability. What layouts work? What don't? Which are best suited for a particular need?
How can I determine if my site is usable by people? How can I make it easier to use? What practices should be avoided?
Serving Paradigms. One Page Serves All vs. Each Page Serves Itself. What are the benefits and drawbacks of each approach?
Overview of old and currently available technologies. What is out there right now? What is being phased out of use, and why?
Templating. There are some nice templating engines out there for just about every langauge... Why was this NEVER MENTIONED in school?
Load Balancing / Server Farms.
JavaScript / ActiveX. When is client side technology appropriate and how can it be USEFUL instead of HARMFUL?
What I Wish They Would Have Stayed Away From:
GIF vs JPEG. Come on...
Deprecation of the BLINK tag. Are you serious?
HTML. Do you really need to spend time teaching CS folk HTML? If they can't learn it on their own they deserve to fail...
JavaScript (the language). See comment about HTML.
ie - Teach me theory, stay away from implementation. Heck, leave all implementation details up to them if you can. They should be able to use whatever technology they want (PHP/mySQL, Ruby/Postgres, ASP/Access with an ODBC connection to an Excel Spreadsheet, Perl/flat files, Assembler/Vulcan Mind Meld, etc) as long as they can show you they they understand the theory.
I can't believe that I wasted my time in a class entitled "Advanced Dynamic Websites" to be talked at about HTML and GIF vs JPEG.
Love sees no species.
I posted a similar question on teaching web development to non-developer types here a few weeks back that may be of interest. I particularly liked a suggestion that I pair my class with a CS class to help broaden the exposure to topics and issues while also making it more likely that the class will get a real-world experience out of the work.
I've come to the conclusion that with non-CS students it doesn't really make sense to try to teach development in the coding sense, but it does make sense to try to teach development as a process.
Interesting reading..
I wasn't however trying to say that HCI experts can't be good programmers as your first link argues. My reply was to the first post stating that they should have a "strong background in programming" to perform their duties.
How much can these students be worth? And people wonder I call university a cult?
In a complex site, you may end up with something like this:
User -> Load Balancer -> Web Server -> Gateway Server -> Application Server -> Database Server
Where there may be multiple branches past the load balancer for any one request. This chaining can lead to a poor user experience, but it generally isn't seen until it's much too late. I speak from experience from a large install of a popular CRM package that had hundreds of users begging for their old systems back.
You can throw all the hardware you want at a system like the above, but it still ends up being a web-based app that has to make a lot of back end calls. No one really thought about how well a user could talk on the phone and use the system at the same time. Management loves the system because it has a lot of data on screen and gives the user more options when interacting with the customer. The users hate it because the system takes so much time to move from function to function that they can't have a decent call flow.
Still, with a plan, you only get the best you can imagine. I'd always hoped for something better than that. -CP
It's best to just let them loose on /.
I'd start with a one-week brief blitz of typesetting concepts (how text can be aligned so as to draw the eye, etc), formatting, design/graphics, and overall layout, with a description of some common layouts in use on large sites. This would be a nice way to kick things off -- show them how to make a site that isn't hideous.
:)
Then, I'd spend a couple of weeks on sound HTML, how to integrate scriptlets properly, how to handle server-side includes and CSS so your code is cross-browser, how to limit your table use to positioning (if even that), how to make your site small and tight, and avoid huge load times.
Next I'd start wading out into deeper water, going into server-side code, handling form posts, working with files and mime types, and configuring the server to handle specific file types correctly.
Next, I'd touch middleware, because no complex site lets its DMZ servers anywhere NEAR a database. I'd give them some sample code implementing something simple, maybe a user account system with a simple mySQL database. This will let you introduce them to transactions (inserts and updates) and regular queries. It'll let you touch on record locking and how it's used, too. You'd be surprised how many grad-level people don't actually understand this stuff as well as they're supposed to.
Once they've got all these bases basically covered, you can start getting funky, storing binary files in a database, uploading them and downloading them via a website, streaming them to a client, arranging access (how to handle user logins and etc) which in turn leads to sessions and how to manage them, and lets you play around with SSL and look at different commercial providers of related tools.
You might want to look at GIS integration, too, because lots of sites are integrating mapping functionality these days. That's a nice advanced topic, worth a week or so...
And, of course, there's always the topic of anonymous proxies, i.e. how to set them up, etc.
And, security of course. You could look at Snort as an example of an IDS, and iptables as a reasonable firewall, and have your students set both up and monitor them over the course of a week. You could have your students pair up, one hunting around with nmap and the other trying to catch him in his logs...
This is a pretty rich subject. How many weeks do you have?
Farewell! It's been a fine buncha years!
I'd at least introduce them to Macromedia's Coldfusion. I know it's become synonymous with Flash, but I see more and more sites popping up with the .cfm extension. It's becoming a standard for business/database/web-based designing.
Dare I say it -- have a look at Phillip and Alex's Guide to Web Publishing. The basic concepts of what makes a good web service were pretty much laid out here. It's all still as relevent as when it was written. This is the important part. The rest is just a technical exercise.
PHP and MySQL are two pillars of open source, there are a lot of resources on them. I would choose a CMS/app framework using PHP/MySQL and build the class around accomplishing tasks in that framework, where each student ends up with a complex website. The framework code can serve as a corpus of examples/best practices and illustrate app design, while the coursework focuses more on user interface, content design, and data management.
A fairly complete list of frameworks can be found at http://www.opensourcecms.com/, with reviews and user comments. My preference is Xaraya, but Xoops or Drupal would be good too. Stay away from the Nukes.
Actually, I am not aware of any high-level "curriculum" of the /concepts/ per-se, except maybe something like J2EE design patterns or something (which willl no doubt describe the concepts and also be applicable to languages like PHP, etc.).
The thing to nail home is:
* impedence mismatch between display (usually HTML + CSS, perhaps originating from serverside XML+XSLT), transport (HTTP, blocking/synchronous protocol), business logic (typically some general purpose language like Java), and database (e.g. SQL) languages.
* different strategies for composing the middle tier: various flavors of MVC (jsp/php, jsp/php with "controller", pure "controller" (or framework) with templating engine, or direct XML+XSLT transformation); not to mention the business logic tier (either combined or glossed over for anything but the largest applications)
* the different skills and aptitudes required to tie this all together (all the technolgoies, frameworks, configuration and deployment steps, etc.)
It's 10 PM. Do you know if you're un-American?
If someone can't program on their own, they sure as hell can't write code that will slot neatly into a group project.
Python is the new C++. It's easier than its predecessors, is not too adventurous or different, and has a lot of power and features. However, for web work it may be slightly out of its element. Yes, Zope and PEAK are cool tools, but they fill a niche that very few web applications fit well into.
If you need a small, fast, or medium sized webapp, no one challenges Ruby On Rails right now. Where that framework fails, Java based solutions start to shine. Subway might be able to get Python into that arena in the next few years, but not this year (and probably not next year either).
I'm a fan of Python, but it's not a terrific choice for web development these days in the face of the competition.
Slashdot. It's Not For Common Sense
Teach them how to hold usability tests in a cost effective fashion, covering both the math/statistics side as well as methodologies. This is essential to the success of any complex website.
Have them learn to look at the features of the available technologies and weigh how their strengths and weaknesses apply to the end user interface (this is mostly going to be looking at cost, development time, maintainability, and reliability).
This class should really focus on the life cycle of evaluating a websites effectiveness, how to improve it, how to design new features to solve business problems, test those features on users, etc.
These lessons will be timeless and get people ready to do real work in the real world. The technology behind it all will constantly change. The students can be expected to pick a good deal of it up on the side, just as they will be expected to during their professional lives. That's the kind of practice they need.
If you're going to skip over CSS why not send them to look at http://www.csszengarden.com/ for homework. It illustrates well the separation of the interface from the engine ... a good point in a HCI class.
"Web Designer's Reference: An integrated approach to web design with XHTML and CSS by Craig Grannell"
ISBN:1-59059-430-4
My ex-girlfriend decided when she moved to this country that she should prepare for a job in IT. So she went to this school that promised to train her.
For two years she had beat into her head "Microsoft sucks. Everybody uses Linux. blah blah blah"
Fortunately she was able to get a job as a staff Accountant entering in invoices.
Take a look to Ajax and Aardvark [link 2] [link 3] [link 4].
Mind Booster Noori
Lomby, is right on. Teach them about project specification and requirements gathering, system design and architecture. Additionally I recommend any information you can provide about MVC design.
It's important to understand at a high level, how applications work. Since these people are in grad school and probably in a management track (or at least not looking for jobs as web application developers), they will need more familiarity with system design and what's possible with existing technology and development methods.
Learning the nuts and bolts of a language's syntax these people will not be writing code in the future and so a quick introduction to xHTML and CSS is about all they will likely ever use.
AF-Design, web development.