the Design Experience Weblog Archive

gksu "sh /cdrom/cdromupgrade"

That sort of worked but ended in an error. So I rebooted then ran apt-get dist-upgrade. That did not work it recommended I run apt-get install -f. This seemed to fix most problems but the wireless was not working.

So I fooled around for a long time. The ndiswrapper-source package won't build since debian/control is missing. I downloaded the latest ndiswrapper and built that and installed it with the latst driver from my laptop manufacturer.

This sort of worked but I could not associate with the access point. I checked /etc/network/interfaces and found a bunch of junk entries for failed wireless setup. I removed all the extra entries and did /etc/networking restart and now I am online.

Here are some of my answers, I am not done yet, answering them. These are my personal opinions, outside of any role I have in any organization.

What state is OpenACS in now?

* Almost there or needs a lot of work?

Definitely almost there, what we need is some focus, that is, to
clearly define what OpenACS can do, and make sure it does it with
a minimum of effort.

* In need of radical, non-backwards compatible improvements or
more conservative, backwards compatable improvements?

* In need of cross package architectural improvements or localised
incremental improvements?
In need of architecural improvements (incremental) in the core
with more focus on how to use the core to get a job done to
create a package. Then use this new focused api to incrementall
improve the packages.

* In need of documentation/idealogical changes or practical code
changes?
BOTH. Document the practical code changes. Define the direction
of the code changes with decisions on the idealogical
changes. That is, decide what OpenACS can do. We ineherited an
infinitely flexbile toolkit. We need to at least give people a
starting place, even if we allow everything we need to give some
direction as to where to start.

Would you like to see all effort focused on incremental improvement? radical change? both in parallel (if so how should it be organised)?

Both in parallel. I think we can make changes to the core,
without breaking too many things, and roll them out across the toolkit.
What is OpenACS?

* A toolkit (ie. complete components which can be brought together
with glue code to make a complete system)?
OpenACS is this.

* A template (ie. a system with blanks that need to be filled in to complete it)?
* A complete system (ie. only required configuration to get a
* finished system)?
.LRN, .dotCommunity can be this

* A content management system (ie. mainly for publishing)?
Not really. that's boring. The community is the content!

* A community / social networking system (ie. focused on
delivering functionality to groups of non-admin users and
enhancing the relationships between them)?
This should be the focus of a product (dotCommunity?)

* A collection of highly interactive apps (ie. a forum, survey
tool, etc and some navigation to get between them)?
Hmm. This is really the same thing as the last one.

Should OpenACS require local customisation or be entirely
configurable?

Blog Post http://blog.daveastels.com/articles/2005/07/05/a-new-look-at-test-driven-development
( related PDF http://blog.daveastels.com/files/BDD_Intro.pdf ) and a video from Google http://video.google.com/videoplay?docid=8135690990081075324

and the Behavior Driven Development Wiki http://behaviour-driven.org/

This arcticle is the first time I have understood what a function is. That's pretty important in doing functional programming. Without understanding the nature of functions (as defined in functional languages) you will never "get it". Now I have it.

The basic idea is this, a function always returns the same return value for the same arguments. It can't do anything else, or its not a function. Simple, and elegant. The article goes on to explain how you can possibly accomplish anything built on this simple foundation. Its good. Go read it.

I remember now that the Berkeley computer science lectures I linked to also explain a function in this way. That is, its always returns the same thing when given the same arguments with no side effects. This was buried inside the rest of a lecture, and I did not understand it in the whole context of what was going on. I am glad I found this article. I found it in a thread asking about the explanation of continuations on a Squeak mailing list.