Free modesto junior college software for linux

Bodington is a free open source Virtual Learning Environment/Learning Management System in use at Universities and Colleges worldwide.

The Bodington project exists to provide an open source environment to support learning, teaching and research.

Bodington project is particularly suitable for complex, multi-disciplinary and large organisations and for inter institutional collaboration. It delivers controlled access using open standards.

Bodington can be used to support teaching and learning across the entire range of learning institutions in the UK and worldwide. Current installations include the Universities of Leeds, Oxford, Manchester; UHI Millennium Institute, Eton College, Yorkshire Coast College and St Andrews College Singapore.

Bodington enables users to upload lecture notes, host discussion fora, publish and manage external links, create interactive resources, e.g. customised logbooks, peer-reviewed reflective diaries/e-portfolios (for PDP), multiple choice tests (QTI), short-answer papers and online surveys. Students can also port work into secure pigeon-holes for marking.

Choose Bodington...

Put material on the web quickly and easily.
Control access to material quickly and easily.
Brand and customise for local look and feel.
Run servers on Microsoft, Linux, UNIX, or Mac OS X platforms.
Run a reliable and scalable service for end users.
Run services for tens of thousands of registered users.
Give access to users on any platform using standard browsers.
Be part of a growing, thriving development community.
Help shape future functionality.
Use software that is built specifically for Further and Higher Education.
Integrate access with partner organisations using built-in Shibboleth functionality.
Keep in line with the JISC e-learning framework.
Customise the source code to meet local needs.
Free up more funds to support staff development, customisation, help desk etc.

Choose other software...

Be tied down to a fixed pedagogy.
Fail in your obligation to support users with disabilities.
Pay an annual licence fee.
Pay for upgrades and support services.
Have little or no influence on future functionality

Acme::OneHundredNotOut is a raise of the bat, a tip of the hat.

I have just released my 100th module to CPAN, the first time that anyone has reached that target. As some of you may know, I am getting ready to go back to college and reinvent myself from being a programmer into being a missionary. I dont forsee that many more Perl modules coming out of this.

Of course, this doesnt mean that Im going to abjure usage of Perl forever; any time theres a computer and something I need automated, out will come the Swiss Army Chainsaw and the job will get done. In fact, we recently needed to manipulate some text from a mission handbook to translate it into Japanese, and Perl was there handling and collating all that.

But 100 modules is a convenient place to stop and take stock, and I hope that those of you who have benefitted from my modules, programs or writing about Perl will forgive me a certain spot of self-indulgence as I look back over my CPAN career, especially since I feel that the diversity of modules that Ive produced is a good indication of the diversity of what can be done with Perl.

Lets begin, then, with some humble beginnings, and then catch up on recent history.
The Embarrassing Past

Contrary to popular belief, I was not always a CPAN author. I started writing modules in 1998, immediately after reading the first edition of the Perl Cookbook - yes, you can blame Nat and Tom for all this. The first module that I released was Tie::DiscoveryHash, since Id just learnt about tied hashes. As with many of my modules, it was an integral part of another software project which I actually never finished, and now cant find.

The first module that I ever wrote (but, by a curious quirk of fate, precisely the fiftieth module I released) was called String::Tokeniser, which is still a reasonably handy way of getting an iterator over tokenising a string. (Someone recently released String::Tokenizer, which makes me laugh.) This too was for an abortive project, webperl, an application of Don Knuths WEB system of structured documentation to Perl. However, given the code quality of these two modules, its perhaps just as well that the projects never saw the light of day.

There are a few other modules Id rather like to forget, too. Devel::Pointer was a sick joke that went badly wrong - it allowed people to use pointers in Perl. Some people failed to notice that referring to memory locations directly in an extremely high-level language was a dangerous and silly thing to do, and actually used the damned thing, and I started getting requests for support for it. Then at some point in 2001, when I should really have known better, I developed an interest in Microsofts .NET and the C# language, which I still think is pretty neat; but I decided it might be a good idea to translate the Mono projects tokenizer and parser into Perl, ending up with C::Sharp. I never got around to doing the parser part, or indeed anything else with it, and so it died a lonely death in a dark corner of CPAN. GTK::HandyClist was my foray into programming graphical applications, which started and ended there.

Bundle::SDK::SIMON was actually the slides from a talk on my top ten favourite CPAN modules - except that this changes so quickly over time, it doesnt really make much sense any more.

Finally, Array::FileReader was an attempt to optimize a file access process. Unfortunately, my "optimization" ended up introducing more overheads than the naive solution. It all goes to show. Since then, Mark-Jason Dominus, another huge influence in the development of my CPAN career, has written Tie::File, which not only has a better name but is actually efficient too.

The Internals Phase

1999-2000 were disastrous years for me personally but magnificent years Perl-sonally. Stuck in a boring job and a tiny flat in the middle of Tokyo, I had plenty of time to get stuck into more Perl development. I felt that getting involved with perl5-porters would be a good way of gettting to know more about Perl, and so I needed a hobby horse - an issue of Perls development that I cared about. Since I was in Japan and working a lot with non-Latin text, Unicode support seemed a good thing to work on, and so Unicode::Decompose appeared, while I fixed up a substantial part of the post-5.6 core Unicode support.

Id recommend this way to anyone who wants to get more involved in the Perl community, although I was very lucky in terms of who else happened to be around at the time: Gurusamy Sarathy was extremely gracious in helping me turn my fledgling C code into something fit for the Perl core, and he also helped me understand the perl5-porters etiquette (yes, there was some at the time) and what makes a good patch, while Jarkko Hietaniemi was always good for suggestions of interesting things for keen people to work on. Seriously, get involved. If I can do it, anyone can.
Anyway, this fixation with understanding the Perl 5 internals, and especially the Perl 5 compiler, (due to yet another of my Perl influences, the great Malcolm Beattie) led to quite a torrent of modules, from ByteCache, an implementation of just-in-time compilation for Perl modules, through B::Flags and B::Tree to help visualising the Perl op tree, to uninit, B::Generate, optimizer and B::Utils for modifying it.

Perl About The House

Now we abandon chronological order somewhat and take a look at the various areas in which Ive used Perl. One of these areas has been the automation of everyday life: checking my bank balance with Finance::Bank::LloydsTSB (the first Perl module to interface to personal internet banking, no less) and my phone bill with a release of Tony Bowdens Data::BT::PhoneBill.

Finance::Bank::LloydsTSB was meant to go with Finance::QIF, my Quicken file parser, to produce another now-abandoned idea, a Perl finances manager. It seemed that Im only capable of producing modules, not full standalone applications - or at least, it seemed that way until I produced Bryar, my blogging software, based on the concepts from Rael Dornfests blosxom and beginning my adventures with Andy Wardleys Template Toolkit. Bryar also tuned me in to the Model-View-Controller framework idea, of which more later.

Another project I briefly played with was a personal robot, using the Sphinx/Festival speech handling and recognition modules from Cepstral and Kevin Lenzo. I didnt have X10, so I couldnt shout "lights" into the air in a wonderfully scifi way, but I could shout "mail" and have a summary of my inbox read to me, "news" to get the latest BBC news headlines, and "time" to hear the time. Of course, getting computers to tell the time nicely takes a little bit of work. I dont like "Its eleven oh-three pee em", since thats not what someone would say if you asked them the time. I wanted my robot to say "Its just after eleven", and thats what Time::Human does. Shame about the localisation.

The Visualization ToolKit (VTK) is an open source, freely available software system for 3D computer graphics, image processing, and visualization used by thousands of researchers and developers around the world. Visualization Toolkit consists of a C++ class library, and several interpreted interface layers including Tcl/Tk, Java, and Python.
Professional support and products for VTK are provided by Kitware, Inc. VTK supports a wide variety of visualization algorithms including scalar, vector, tensor, texture, and volumetric methods; and advanced modeling techniques such as implicit modelling, polygon reduction, mesh smoothing, cutting, contouring, and Delaunay triangulation. In addition, dozens of imaging algorithms have been directly integrated to allow the user to mix 2D imaging / 3D graphics algorithms and data.
The design and implementation of the library has been strongly influenced by object-oriented principles. VTK has been installed and tested on nearly every Unix-based platform, PCs (Windows 98/ME/NT/2000/XP), and Mac OSX Jaguar or later.
Many resources exist to help you utilize the full potential of VTK in your application area. These resources include:
Mailing List: Over 1900 users are subscribed to this list. A great place to post questions, and search for answers.
VTK Textbook: The Visualization Toolkit, An Object-Oriented Approach To 3D Graphics, 3rd edition, ISBN 1-930934-12-2, now published by Kitware. This is a great book to read if you want to learn the details of the visualization algorithms and data structures. The book is often used as a college text in visualization and graphics courses.
VTK Users Guide: The Visualization Toolkit Users Guide, ISBN 1-930934-13-0, published by Kitware. This is the book to get if you want to learn how to install and use VTK.
ParaView Guide: The ParaView Guide, ISBN 1-930934-14-9, published by Kitware. ParaView is a turn-key visualization system build on top of VTK, and makes VTK easier to use with an interactive, point and click interface. ParaView also supports supercomputing applications, including tiled display and distributed parallel processing.
CMake: Mastering CMake, ISBN 1-930934-11-4, published by Kitware. CMake is the premier, cross-platform build system used to compile and link VTK. A useful book if you want to use VTK in your projects.
Support: A variety of support options are available ranging from the single point-of-contact Professional Subscription to get you up and running, to custom Site Support to help you develop your next product with VTK.
Enhancements:
- Many bugs were fixed, including fixes for memory leaks, array bounds errors, and stack overflows.

JAdvisor project is a college class scheduler, course planner, and course search program.
It also allows college students to view their schedules graphically and create an optimal schedule.
Adapters are used to customize JAdvisor for your particular school.
Enhancements:
- SchoolAdapter throws new Exceptions
- Added SplitPanes to SchedulerUI and PlannerUI
- PlannerUI displays semester names
- Text Box bug fixed
- Scheduler UI bugfixes
- NCSU adapter bugfixes
- UNC adapter updated

Mathfun.py project s a rather small Python library that contains some of the more obscure (others would say less useful 8^) mathematical formula/functions that I have always found interesting/amusing.

These include primality tests, fibonacci sequences and turning characters into numbers, among other things. The next paragraph includes a little story about my strange habits as a teenager. The paragraph after that contains some ramblings about primes and formulas.

The paragraph after that hasnt been decided on yet, but you can be assured that it will be more stream-of- consciousness rambling about something mathematic by yours truly.

One of the reasons that this library exists is that, as a junior programmer in high school, I spent an insane amount of time writing BASIC programs on our IIgs that would calculate the first 100 primes or some other such nonsense. I would write it one way, get out a stop watch, run it, record the time it took, rewrite it, rerun it, retime it and calculate the difference as percentage decrease in time. Repeat the previous until you get BASIC that looked like an explosion in a type factory. All in some sort of quest to... well, I dont really know what I was shooting for. I just enjoyed it. Calculating if a number was prime, calculating the prime factorization, calculating the first N prime numbers... Yeah, I was a strange one.

But, in retrospect, all that solitary math kinda helped. While I reinvented many a prime wheel, I did it on my own, which was something of a personal fulfillment once I had learned more of a history of mathematics. And I never forgot most of those formulas that I worked out on that Apple. For instance, mathfun.isprime(number) utilizes most of what I learned back in high school. It iterates through the odd numbers, up to the integer value of the square root of the number in question. I still remember the epiphany that I had that I only needed to calculate through the square root of the number. 8^)

Theres a minor paradox with the calculation of a prime. The quickest way to generate primes would be to only attempt modular arithmetic with prime numbers. However, to do it that way means that you have to generate a list of prime numbers first, which involves a primality test on every odd number up to the square root of the number in question. This would be sloooooow for the primality test for any single number. (For instance, isprime(10000) would involved roughly 50 full primality tests to generate the list needed to be a maximally efficient test on it.) So, we accept that even if were not going to get any results doing (N mod 9), its much quicker to eat those wasted cycles than to determine if 9 is prime first.

However, if youre doing nothing more than simply cranking out prime after prime, it becomes much more efficient to only do the primality test with a list of primes, since (if you start from 2) youve already determined the ealier ones before. (Theres probably a break-even time first (machine dependent) before "determine all primes with primes" becomes more efficient than "crank through the odd numbers".) Its easy to see however, that for very large numbers its much better to only work with primes.

Theres also a minor question of the speed of the data structures used to store the prime list versus the very fast next odd number test. However, Ill leave that one up to the True Computer Scientists.

NeoBio project consists of Bioinformatics algorithms in Java.

What algorithms? The current version consists mainly of (pairwise) sequence alignment algorithms such as the classical dynamic programming methods of Needleman & Wunsch (global alignment) and Smith & Waterman (local alignment).

Anything else? Yes, a more efficient approach, due to Crochemore, Landau and Ziv-Ukelson is also available.

It uses Lempel-Ziv compression to speed-up the computation of the dynamic programming matrix. It also relies on the SMAWK algorithm, due to Aggarwal et al., that computes all column maxima of a totally monotone matrix in linear time.

Hum... And all sequence alignment algorithms support simple scoring schemes as well as substitution matrices such as standard BLOSUM and PAM matrices. But so far they support constant gap penalty functions only.

Future versions may contain related algorithms such as multiple sequence alignment, database search and protein structure prediction.

Wow...Last but not least, NeoBio also provides a simple GUI and command line based tools to run the sequence alignment algorithms on DNA and protein sequences.

SchoolTool project is a common information systems platform for school administration.

SchoolTool is a project to develop a common global school administration infrastructure that is freely available under an Open Source licence.

The vision is to create a platform that is equally compelling for schools and colleges in First and Third World countries, that supports best practices in school administration, and that is readily customized to comply with local regulatory requirements.

It is based primarily on Zope 3, with an HTML interface and a Web service interface in the REST architectural style.

Install step-by-step Instructions

OK, using the aforementioned shell script makes things easier, but there are still a few steps you need to pay attention to.

You need a C development environment (build-essential on Ubuntu) and Python development libraries (python-dev on Ubuntu).

You need the Python Imaging Library (python-imaging on Ubuntu) and the Python libxml2 bindings (python-libxml2 on Ubuntu).

You need a very up to date version of Python setuptools, which will probably require downloading a new version of ez_setup.py and running that script as root.

Now you can download alpha2-install.sh to whatever directory you like to use for testing software and do chmod +x alpha2-install.sh to make it executable and then ./alpha2-install.sh.

Hopefully it will then set up the rest of your environment and give you some final instructions when it is done. You will probably get one error message when it runs the tests. Please ignore it.