Free study software for linux

This study guide from Linux Holdings will help you to train for the Linux LPI 101 exam.

Linux Holdings is a linux and Open Source training company, training Linux Administration as the core focus.

These are not the only Open Source courses we offer, but the most popular.

Training info

Linux Holdings offer a full spectrum of Linux and open source courses. These start from basic low-level courses to the very advanced administration courses.

All our administration courses are based on the international LPI certification. Our trainers are the best available in South Africa. They are not just excellent Linux administrators with many years experience; they are also the best trainers in the industry. Good administrators are not necessarily good trainers; we give you the best of both sides.

Our entry-level and intermediate courses include the ICDL for OpenOffice.org. We have a full marketing and development department constantly developing and updating courses. Linux Holdings invests huge amounts of time and resources in development, testing and research to give the best training available today.

Our quality department ensures that all students are trained to the highest standard possible. It is also the quality departments duty to ensure that students start with the right course so the learning gradient is not to high or to low. Speak to us so that we can suggest the proper courses for your IT experience.

IVuPy (I-View-Py) aims to be a solid basis for large Qt based Python programs geared to data analysis and 3D visualization of huge data sets.

Python is extended by IVuPy with more than 600 classes of two of the Coin3D C++ class libraries: Coin and SoQt.

Data exchange between Python and the Coin3D data structures is based on the Numerical Python extension modules (any combination of NumPy, numarray, and Numeric).

IVuPy requires at least one of the Numerical Python extension modules, either NumPy, either Numeric, or numarray (IVuPy works with all of them at once). The Numerical Python extension turn Python into an array processing language like Matlab or IDL.

The data transfer between the Numerical Python arrays and the Coin3D data structures has been implemented in C++ for efficiency.
IVuPy has been built using SIP, the interface generator for PyQt. This assures optimal integration with PyQt and very efficient bindings as exposed in Python Wrapper Tools: a Performance Study.

SIP bindings blur the distinction between wrapped C++ classes and Python classes and enable powerful subclassing in Python. For instance, viewer.py demonstrates how customization of event handling can be implemented in a subclass of SoQtExaminerViewer by reimplementing SoQtRenderarea::processEvent().
IVuPy does a bounds check when accessing an element of Open Inventor data structures (SbVec, SoMField), and raises an exception when the check fails.

Tntdb is a c++-class-library for easy access to databases. The interface is database-independent. Driverclasses are loaded dynamically.

The goal of it is to have easy access to databases. You dont have to worry about resourceleakage, because all objects you use directly are allocated on the stack and deleted automatically, when going out of scope. The interfaceobjects are wrappers to referencecounted instances, so you can copy them around at your own will. Resources are freed, when the last object goes out of scope.

Errorhandling is done exclusively with exceptionhandling. Just wrap your code with a single try-catch and you have full errorhandling. Exceptions are all derived from std::exception.

STL is used where possible and also STL-like and -compatible interfaces are offered, where suitable.

Tntdb is targeted for applicationprogramming. It is not suitable for generic databasetools. It does not offer e.g. schemaquery. You have to know, how your tables look like. Thats true for normal applications.

You use SQL for databaseaccess. No wrapperclasses like active resultsets or databound controls are offered. Instead you have best control over the database. You can use every SQL-trick you know to get most out of your database. Also this is a thin wrapper, so that you should have no big performancepenalty compared to direct access to the C-API.

The project started already some years ago as a postgresql-wrapper. Later I added a sqlite-3-wrapper.

The current status is, that there is a working mysql- and postgresql-driver-class. The sqlite-3-wrapper is included here, but it is just a early design-study. Tntdb works, but it is not dynamically loaded like the other drivers.

The public headers include documentation, which can be generated using Doxygen.

Also there are some small examples in the demo-directory.

SURVIVOR is yet another systems monitor.
Does the world need yet another systems monitor? Well, the world has had the Backstreet Boys, N Sync, 98 Degrees, Take That, Boyzone, Westlife, 5ive, O-Town, not to mention New Kids on the Block, All-4-One, Boyz II Men, New Edition, and Menudo, so clearly there is an ability to accept and even appreciate redundancy. Not that one needs to appreciate boy bands to appreciate systems monitoring, and perhaps now would be a good time to underscore that the SURVIVOR project does not endorse or even listen to boy bands.
Differentiating systems monitors can be a lot like differentiating boy bands. At first glance, they all look alike. With careful study, however, they all still look alike, except that some have goatees and others dont. With further study, it is possible to detect different accents, but no matter how far you look you still have a boy band.
In this respect, SURVIVOR is a lot like other systems monitors. It was written because of requirements that dictated the equivalent of a boy band with two Americans, two Brits, and an Australian, two with goatees, three brunettes, and not all of them living in the same town in Florida.
Unlike most boy bands, the core of SURVIVOR is a POSIX-thread based scheduler, responsible for determining when services should be checked and when alerts should be transmitted. The scheduler should be highly scalable, although it has not yet been tested against an entire class B network.
Like almost every other package, check and alert modules may be written in any language. These modules should generally scale quite well, although specifics depend on what the module actually does.
A command line interface, web interface, and two-way messaging gateway are provided.
Unlike most boy bands, SURVIVOR is intended to be a very high quality, feature rich, package. It is unlikely to ever get airtime on TRL.
Enhancements:
- In addition to the usual bugfixes, this stabilization release adds five new check modules, a flap reporting module, and adds various improvements to the command and Web interfaces.
- This is the first release with accompanying RPMs.

FlashKard project is a vocabulary training tool.

It is designed to be used in any situation where a fixed set of vocabulary (technical or linguistic) is to be learnt.

FlashKard is a vocabulary studying tool for learning languages or terminology.

Its currently included into KDE.

Guarded Memory Move project gets handy when you have to study buffer overflows and you need to catch them together with a "good" stack image. When a stack overflow has been exploited, the back trace is already gone together with good information about parameters and local variables, that are of vital importance when trying to understand how the attacker is trying to work out the exploit. The GMM library uses dynamic function call interception to catch the most common functions that are used by attackers to exploit stack buffers.
The GMM library uses the LD_PRELOAD capability and offers two services to the user. First of all, it avoids buffer overflow to allow the attacker to execute shell-code on your machine. Second, in case where an exploit is detected, the stack content is saved and a segmentation fault is triggered. The resulting core dump will then have all the necessary information to debug the exploit and fix the software. Internally, the library insert itself between the application and the glibc library and intercept functions that might lead to buffer overflow exploits. Before calling the glibc core function, the GMM layer saves part of the stack frame above the caller to a temporary location in its frame.
It also stores the previous three return addresses in its local storage before calling the glibc core function. When the core function returns, the GMM code samples again the previously recorded return addresses and, if they differ, it restores the previously saved stack frame and issue a segmentation fault. This with a clean stack frame, so that it can be inspected with a debugger. While other solutions exist to detect buffer overflow exploits, like for example StackGuard and StackShield, those differs from GMM in many ways. They live as gcc patches and do require you to rebuild your application to use their functionalities. The good of this approach is that every single function is protected against buffer overflows.
The bad of this solution is that every single function is protected against buffer overflows. That is, performance regression on the whole application, even if this is not really a huge problem when hunting for buffer overflows. Another solution similar to GMM is LibSafe, but it does not save and restore the stack frame by making it unusable for debugging. But lets see how GMM differs from the above listed solutions. First of all, GMM works everywhere there are stack frames and the gcc and glibc duo. That means that it is not limited to i386 only. And now the real reason for the GMM existence.
Enhancements:
- GCCs __builtin_return_address and __builtin_frame_address seems to return garbage instead of NULL at the last frame. This release fixes the problem.

Simulum deals with different simulations of star movements and their visualizations. At first we look at the projection and accumulation of star brightness.

In actually doing this we have to distribute stars among a three dimensional figure. To get a nice effect we combine the photographic image production with a moving view point. So we get the visual impression of flying through a star field.

Secondly we will study different algorithms of particle movements and clustering. The primary approach will use a combination of Newtons gravitational law, energy and impulse conservation.

At all these stages an highly dynamic view of the processes could be produced and will lead at least to interesting screen savers...

Whats New in This Release:

ï¿1⁄2 A huge refactoring phase took place.
ï¿1⁄2 Now the code is much better organized.
ï¿1⁄2 A simple gravity engine is included, so you can watch gravity at work.
ï¿1⁄2 It has now a nice GUI.
ï¿1⁄2 You can browse the simulation with your mouse.
ï¿1⁄2 The provided unsigned jar includes an applet that can directly be used by HTML pages; this release includes sample HTML pages.
ï¿1⁄2 You can also webstart the signed jar or start it with "java -jar lib/mulumis.jar".