On Feb 23, 3:38 am, kcrisman <[EMAIL PROTECTED]> wrote:
Hi,
Du to lack of time and need for sleep I will only touch a couple
issue.
> Great thanks are due to Jason G. for starting to distill some of the
> issues involved in the developments leading to sage-edu in a very
> gracious manner. I hope to add, in a similar vein (nothing about APIs,
> sorry!), more commentary on some more of the underlying issues, and a
> request to the "main development team" (a fluid term in an open source
> project) for some suggestions to help the rest of us contribute more
> substantially.
>
> As a relative newcomer to open source, it's been interesting watching
> some of the same growing pains and sociological issues that Eric
> Raymond (and other more scholarly outside observers) describes so
> well. Particularly interesting is that here it seems to come from the
> (fairly atypical?) fact that a significant number of true end users of
> a program have been directly involving themselves in development, even
> if primarily via feature requests and not as much via code.
>
> I say particularly interesting because the highest profile open source
> projects (e.g. Mozilla, Apache) are used by millions of people daily
> without any thought to development, and in my grad school days most of
> us who used very important ones like Linux and TeX asked someone else
> nearby with questions, and never thought to ask a developer for an
> enhancement! I sense a much higher proportion do with Sage.
>
> In addition, with Sage we have a program with developers and end users
> with remarkable affinities - to its credit. It is being used by
> scores of people outside the (early) original target audience who are
> just expert enough to understand what is going on behind the scenes
> and are also excited about the primary use (here, math research), and
> yet is being developed by people who largely have some experience and
> affinity to those additional uses (here, pedagogical). This is
> largely because, at heart, mathematics is a much more unified
> discipline than some others.
>
> However, there is nonetheless a fundamental asymmetry with any
> technology between those who know how to use it most profitably and
> those without that expertise (e.g. medieval users of Roman numerals
> fighting against the introduction of decimals as a "leveling"
> influence). This asymmetry isn't inherently bad if the non-expert is
> given the benefits of the technology fairly; in fact, it can promote
> efficiency since the non-expert can become expert in something else.
> Certainly in a case like Sage, it doesn't stand in the way of bugs/
> features that *everyone* wants to catch/use being thought of with
> amazing swiftness, because of my above point.
>
> But this asymmetry can become a problem. Sage seems to have fallen
> victim to its own success,
Not at all, there are more users (easily an order of magnitude, maybe
more depending on the time frame you look at) and there are more bugs
discovered (much less than an order of magnitude) because of it, but
overall we are holding our ground. The turnover of fixing issues is
high enough that on average no real bugs should survive on average two
to three months (note that I claim that for bugs, not enhancements)
and as the number of users does grow the number of developers does
also increase, albeit with a delayed reaction.
> for instance in discussions about the cube
> root of -1, or in increasing demands on time of the core developers
> for what are essentially side issues.
Nope, it is a real bugs that needs fixing in form that we return a
better error message.
> Anyone in academia should be
> very sympathetic to time constraints, but the real issue is not that
> there isn't enough time, but that a conscious (and reasonable) choice
> has been made to focus Sage development on things like modular forms.
> However, that leaves the question of how to continue improving the
> more pedagogically useful aspects of Sage (e.g., the notebook and
> calculus package), which everyone seems to agree is a very good
> thing.
The notebook is in no way education specific. William & others wrote
the initial version because it was useful for their research. That it
is useful in settings like education is just a side benefit to the
other users. The notebook could certainly use some polish, but we are
far from a situation where drastic measures need to be taken. And
people like Jason Grout have clearly shown that a cooperative,
incremental approach is possible from the educational side of the pool
of users and developers.
> (Here comes the part where I ask for help.) I think that most
> pedagogical Sage users would like to help in ways that they can, and
> most research Sage users really do appreciate being able to make a
> quality competitor to "the M's" for teaching purposes at no (monetary)
> cost. So what I am asking for (perhaps on sage-edu, certainly not
> here) are concrete suggestions for how that can happen, given several
> limiting factors. I outline some of these limiting factors at length
> below, and offer tentative suggestions for some of them.
>
> The bottom line is this; what mechanisms can be put in place now to
> help the education community create patches, and eventually
> significant code,
Some users become developers, regardless of the background. I have met
so many excellent research mathematicians who couldn't code their way
out of a wet paper bag it isn't even funny, so I seriously doubt that
there is any correlation between research mathematicians and
programming ability. The fact that research mathematicians write the
majority of the code is probably due to the fact that most of them are
used to crude tools and so had less of a problem adopting Sage in its
earlier stages. But since some users become developers (as I mentioned
at the beginning of the paragraph) eventually there will be a critical
mass that will make Sage a better tool for teaching, it will just take
a while until people move up the food chain of development.
> without needing to constantly divert developers from
> the core directions of Sage? Then a call to "show me the code" (which
> Jason already pointed out is eminently unreasonable at this time)
I beg to differ. Ted's first question was to ask who "owned the
notebook", which was not what sage-edu was intended to be. Sage edu
was meant as a germination site to build a community that is *part* of
Sage. sage-edu is supposed to be a place with a better signal to noise
ratio and where people with the same goal get together to solve their
problems. He also talked about doing releases and hence my question
question about code is justified. No code \Rightarrow no release. End
of story. Formulating visions is not the answer, writing code is. We
don't live in the future, we want a product *now*. And that involves
getting down and dirty and doing the best you can with the tools that
we use, not the tools anybody things would be better suited for the
job. Claiming that "wouldn't it be nice if ... \Rightarrow world
domination" doesn't get you very far. I disagree with much of what Ted
has/had to say on a technical level, but at some point I didn't keep
my mouth shut any more, but I started asking that question and it was
no accident that formulated it that way.
An open source project is not a democracy, it is about the people who
contribute, be it in form of answering email on lists, writing
documentation, writing code or even filing bugs. Ted did write
documentation and code ans answer questions on the mailing list, but
except for his jmol-src.spkg (which was much appreciated) not a
*single patch* has even been merged in the Sage repo. Ted has his own
vision, his own preferred set of tools (Java & OpenOffice) which is
not shared by the vast majority of Sage developers. The reason that
none of his patches was merge is not about Java, but because he never
submitted a single patch via trac. He later pointed out that there are
70+ open tickets in trac that are notebook related and that he had
read the code and found it insufficiently documented, which anybody
who has ever worked on that code knows. So why didn't he do something
about either the documentation or about the many open notebook issues
and submit a patch? That is how things get done, not sitting on the
sideline and working on your own set of toys.
I know about the JSON.spkg, but getting code into Sage these days
requires peer review and Ted never popped up once in IRC [that I
recall] or lobbied the release manager personally to get things
reviewed and merged. Code doesn't make it magically into Sage these
days, but you need to work on it. The reason is plain and simple that
we want to increase the quality standard of Sage and just merging
because one person has an interest in it doesn't cut it. Look how long
it took to finally solve the 3D plotting problem, and that was a major
thing on William's list who has more than enough influence as you
imagine to get people to work on his goals. And William's point of
view to enable implicit multiplication by default got even vetoed by
the JSage board, so nobody is above the law around here.
Ted's Newbie book should be part of Sage, but since it is written in
OpenOffice it doesn't fit in with the rest of the documentation and
since OpenOffice's format is zip compressed XML files there is no way
to develop it by submitting patches, which is the way things are done
around here. Ted for some reason prefers to do insular development and
that is not how Open Source projects work. Maybe he will be happier in
another community, but to tell you the cold, hard truth: We will lose
[potential] developers because of difference of opinion and
development preferences. That is just how things work, you cannot make
everybody happy. Contrast that with the fact that *35* people got
patches into 2.10.2, released an hour or two ago. The 2.10.2 release
cycle was longer than usual (3 weeks), but if you subtract the week of
Sage Days 7 we finished right on the upper bound of 2 weeks per
release we usually have. That number is a very impressive number for a
project the size of Sage.
So the Sage community is very vital and will survive without Ted, it
will survive once I or any other developer walks away and by now I am
even convinced that it will survive if William were hit by a bus, just
like the Linux kernel will survive if something did happen to Linus.
Overall the speed of development is accelerating and while individual
contributers might drop in and out due to work, life in general, a PhD
thesis that needs finishing or whatever else, as a group everything is
going very well.
And one last note on the notebook: It is very likely that Sage will
finally make it into the next Google summer of code and I am very sure
that the main emphasis for projects there will be on the notebook. So
by fall we should have a much improved notebook.
> might have a chance to be honored not just in the breach. If we can
> do this, for the first time a totally free option which supports
> mathematics in pedagogically sound ways all the way from arithmetic
> and geometry to arithmetic geometry will exist, with huge benefits for
> anyone who cares about more than one level of mathematics.
>
> - kcrisman
>
> Here Follows A Perhaps Superfluous Long List Of Limiting Factors and
> Suggestions Which Might Help Combat Them.
>
> Limiting Factor 1: If research mathematicians and grad students are
> pressed for time, many high school teachers and professors at teaching
> institutions have been squeezed completely dry before they ever embark
> on trying new things like Sage. Sometimes they are actively
> discouraged from it, though that hasn't been my experience. I don't
> know that there is much one can do about this, but I put it first
> because it directly impacts all the other limiting factors.
>
> Limiting Factor 2: Who is trying out Sage from the education
> community? My sense is that to some extent they are people at
> institutions which do not have enough resources to afford site
> licenses for the competitors of Sage in the first place. These
> institutions tend to be precisely the ones where teachers are least
> able to find time and least likely to already have the experience to
> conquer the other factors. It seems like Sage is starting to
> alleviate this somewhat by attracting education people who hear about
> it through its research aspect, but there is more work to be done in
> finding people who can help and are willing to leave the big boys.
> The JMM booth was a huge step in the right direction.
>
> Limiting Factor 3: Many educational would-be developers are not really
> sure what is needed to implement that can be done on a step-by-step
> basis, other than by finding bugs or comparing with other programs.
> This has already been discussed quite a bit elsewhere. An additional
> suggestion would be that a Moore-method style list of functionality,
> each step of which could be implemented by someone without a full
> grasp of the larger development vision of Sage, could be helpful (e.g.
> define some minor class, write these methods for it, interface them
> with this other class, add these basic examples, etc.).
>
> (A personal note relevant to this factor and the next is appropriate
> here. I've learned far more programming than I ever dreamed I would
> through Sage, and it's been exhilarating. I would love a list of
> theorems like this, similar to the Euler thing someone else mentioned
> a while back for learning Python. But there is no way I will be able
> to contribute more than here and there *on my own* without radically
> restructuring my work load, which would mean getting a different kind
> of job, or even not having one at all. I wish Sage had existed when I
> was a grad student!)
>
> Limiting Factor 4: The fundamental technological asymmetry will
> persist. Although people like David Joyner and (now former
> developer?) Ted Kosan do have the experience to do so, many of those
> fairly interested in education who Sage will want to attract to this
> simply will not have anywhere near the background necessary to do real
> development without a lot of hand-holding or an intensive course in
> things like server interaction and the ins and outs of initialization
> and overloading.
>
> A possible solution to this, though a very expensive one, would be to
> find funding for a summer Sage Education Days where precisely this
> sort of thing could happen, leading to a much more independent
> education group. Others will know more about this, and it's been
> mentioned, but it would seem that there is a lot of federal money out
> there for helping develop already-tested programs in the educational
> context. Even GeoGebra, a German product, seems to have done so in
> this country, and there are lots of far poorer-quality and far more
> localized (in geographical use) programs than Sage to have gained such
> funding.
Well, it is very difficult to do and William failed with the
educational angle, while it has proven not so difficult to get funding
for general Sage development or ports to Windows and Solaris. Getting
to those educational source of funding requires political muscle and I
am not sure who in the Sage community that person will be who makes it
happen.
> On a more immediately realistic level, a modest program of regional
> weekend events with a small registration fee asked of participants
> could attract enough people to be worthwhile as well.
>
> Limiting Factor 5: Not-yet-developers receive mixed signals on how
> much support they can expect on sage-support, particularly in terms of
> requesting functionality. Sage has some extent become a victim of its
> own success - many of us, especially "early adopters" (pre-slashdot)
> got immediate responses on sage-support or to personal emails, and
> started relying on that help, rather than switching programs or just
> giving up on using a computer mathematics program. An impartial
> observer of that and the huge increase in downloads would have seen
> the trouble ahead.
Well, there isn't anything you can do about that. Once the slashdot
story broken we were all just along for the ride. I still don't see
the quality of sage-support or sage-devel declining and the closing of
sage-newbie and sage-forum was a direct reaction of perceived lack of
response since too few knowledgeable people read those groups. Those
were two isolated cases where the people became vocal.
These days if you want rapid feedback or interactive discussions drop
by in IRC in #sage-devel and while the best time to do so is late in
the evening PST time usually within an hour or so you get a response.
And during releases, Bug Days and other meetings the channel is
teaming with people. It isn't exactly a secret these days that a lot
of discussion happen in IRC and that many decisions about technical
directions are first discussed in IRC before popping up on sage-devel
to finish out the discussion there.
> The reason this is a limiting factor to educational developers is
> simply frustration of not knowing when it's time to start and when
> it's time to ask. I have absolutely no idea what to do about this;
> brusque responses of not having time (or no responses) will turn off
> brand-new users as much as answering endless sequences of continuing
> trivial questions will turn off long-time developers. The creation of
> sage-edu could be a step in the right direction, or it could be a dead
> end. It doesn't sound like sage-edu folks (if that proves to be a
> viable long-term concept) would not be discouraged from asking
> continued questions of sage-devel or even contributing to discussions
> there, but making this clear is essential to its viability.
Nobody has ever been flamed in the Sage Google groups for asking
[stupid] questions and sage-edu is not meant to be the softer side of
development. We have FAQs and plenty of documentation. If you ask a
question because it wasn't in the FAQ then add the question and answer
yourself once you get it. This is the way we build a community and the
Sage community is much more friendly and quick to react than
comparable technical or mathematical groups. Go ask a stupid question
on the GMP mailing list and you will for sure notice the difference.
Time to stop ranting.
Cheers,
Michael
--~--~---------~--~----~------------~-------~--~----~
To post to this group, send email to sage-devel@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/sage-devel
URLs: http://www.sagemath.org
-~----------~----~----~----~------~----~------~--~---
