Free hood software for linux

SML is a "toy" machine language intended to teach basic processor concepts. This website contains an explanation and definition of SML, as well as an interpreter and example SML programs. GPLd source code for the interpreter is available, as well as binaries for Windows and Linux.

A machine language defines a set of instructions that a CPU can execute to perform operations. In other words, a machine language defines what you can do with your computer. Modern processors have very complex instruction sets; however, the simple language described here can give you an understanding of what is happening "under the hood" with your computer.

Machine language is the actual data that is directly run by the processor. Writing a program in machine language can therefore be advantageous if you need to save space or highly optimize your code. However, machine language is also not portable and can be difficult to understand and maintain.

Therefore, almost all code is now written in a higher level language, such as C, C++, Java, or scripting languages such as shell or perl. These languages all have their advantages and disadvantages as well, such as varying levels of portability, maintainability, scalability, and execution speed.

One level higher than machine language is assembly language. Assembly language is basically readable machine language. Instead of writing out the code bit-by-bit, you write out the code as a sequence of human readable instructions, which are then compiled almost directly into machine language.

Assembly language is almost always used instead of machine language when such a direct level of control is needed. For example, some games implement part of their code in assembly in order to maximize execution speed. Assembly can be "inlined" into some higher level languages, like C. This means that the assembly is defined as a callable procedure from within the C code.

OSCache is a high performance J2EE caching solution that can cache portions of JSP pages, entire HTTP responses (including dynamically generated images), and arbitrary Java objects.
OpenSymphony Cache can provide your J2EE application with huge performance gains and graceful error tolerance (e.g., in the event of a DB failure, cached content is served).
Fast in-memory caching
OSCache allows you to execute dynamic content periodically (eg every 30 minutes) rather than every request and store the result in memory. Each further request is served directly from the memory cache, resulting in dramatic speed increases.
The cache is keyed programmatically. This means you can calculate a cache key that works for your situation. For example an ecommerce site might use product ID as keys, or content site might use an article date and article ID combination.
The cache is stored in standard scopes that any JSP programmer is familiar with (application or session). The session scope allows you to have different cached content per user. This is one unlike any other caching system weve ever seen.
Persistent on-disk caching
OSCache can also write the cache to disk. This provides caching across server restarts, and caching of datasets that do not fit into memory. Caching can be configured to use memory or file caching, or a combination of both.
If you want to persist the cache to somewhere other than disk, you can plug in a custom PersistenceListener. This allows you to persist the cache to anywhere (for example to a database via JDBC or to LDAP via JNDI).
When using both disk caching and memory caching. It is possible to limit the cache size to avoid using too much memory but let disk cache unlimited, resulting in browser style complementary disk cache. When cached objects are removed from memory, they are still on disk. If the item is needed again and it is not expired the cache file will be used. This also gives fault tolerance if the server crashes.
Persistence can also be switched to overflow mode using the property oscache.persistence.overflow.only. This changes the default behavior (of persisting every cache entry when there is a listener) to only persist when the memory cache capacity has been reached.
Excellent Performance
Written with performance in mind.
Mulitple cache requests can be handled concurrently.
Only one requesting thread needs to update an expired cache entry even if multiple threads are requesting it simultaneously. Other threads can be configured to either receive the recently-expired object, or block until the cached object is updated. Similarly, when a new entry is being added to the cache, other threads requesting that entry will block until it is ready rather than run off and race to build the same object. In a high load environment this can provide enormous performance benefits.
Automatically takes advantage of JRE 1.4 or higher if available.
Clustering support
OSCache can easily be configured to cluster across multiple boxes. This provides both scalability and failover support without any changes required in your caching code.
Flexible Caching System
OSCache allows you to cache portions of JSP pages, arbitrary Java objects, and even entire servlet responses.
Cache capacity can be set allowing you to limit the number of cached objects.
Multiple caching algorithms are supported such as LRU (Least Recently Used), FIFO (First In First Out), or unlimited. It is also possible to plug in your own custom algorithm.
You are given a huge amount of control over the way cached objects expire. Objects can be cached indefinitely, expired once they reach a certain age, or expired based on a cron expression. Programmatic flushing is also possible, and if that is still not enough pluggable RefreshPolicies allow custom refresh strategies.
Cached objects can be grouped together however you like, allowing for powerful management of cached data. This is an extremely useful feature that is far more powerful than what other caching solutions typically offer (such as the flushing of cache keys that match a particular pattern).
Fully event driven! OSCache fires events for various happenings under the hood such as cache entry events (adding, updating, flushing and removing) and cache accesses (hit, stale hit and miss). It is easy to add your own event handlers.
Multiple caches can be created, each with their own unique configuration.
Simple JSP Tag Library
The tag library to perform and control the caching is very simple. See the Tag Reference for more information.
Caching Filter
A Servlet 2.3 Filter allows for caching of entire pages and generated binary files (like dynamically created images or PDF files).
Comprehensive API
For the ultimate control, OSCache can be used through its straightforward API. You can instantiate, configure and control multiple caches programmatically. It would be possible for example to create one small in-memory cache that held currency conversion rates and was updated daily at 2am, while another cache could be purely disk based and used for holding dynamically created images.
Exception Handling
OSCache provides a way for your site to gracefully tolerate errors. This is not error prevention, rather if an error occurs it should not stop your site from functioning. For example if your database goes down, normally your product descriptions will not be browsable. Using OSCache you can cache those descriptions so you can still browse them.
Cache Flushing
Flushing of caches can be controlled via JSP Tags, so these functions can easily be built into your administration interface.
There is programmatic control over what caches are flushed (eg all caches or just a particular scope).
Cached objects can be expired in a number of ways. Objects can be told to expire once they reach a certain age, or, through the use of cron expressions, on particular dates and/or times (eg it is trivial to make an object expire every weekday at 3am). If this is not enough, you can expire objects programmatically as required, or plug in your own custom RefreshPolicy class that can dynamically decide when an object should be flushed.
Entire groups of objects can be easily flushed from the cache. For example suppose you were caching product data as well as entire pages of your website. When a product was updated, you could flush not just the product object but also all the pages that contain information about that product. No more waiting for the cached objects to expire before the updated content shows up on your site!
Portable caching
Pure Java, this means it is platform independent.
OSCache is compliant with Servlet 2.3 and JSP 1.2 standards, which means it should work in the latest generation of servlet containers and application servers.
i18n Aware
The caching is i18n aware and supports all encodings.
Solid Reputation
Thousands of downloads, hundreds of users on the mailing list.
Comprehensive JUnit test suite that covers every aspect of OSCache, including a web stress test and various concurrent cache access scenarios. To back this up, the kind folks at Cortex have supplied us with a Clover license to provide detailed code coverage analysis of our unit tests.
We have solid issue tracking using JIRA to keep track of any feature requests, bug reports and development progress. JIRA is provided courtesy of Atlassian.
Enhancements:
- CRON expressions to expire content at specific dates and/or times.
- Pluggable EntryRefreshPolicy.
- Reduced memory consumption.
- Faster disk persistence.
- DiskPersistenceListener deadlocks are avoided if a process has no rights to delete the cache file.
- There is a new JSP tag _addgroups_, and an interface to get a list of the cache event listeners.
- The commons collection dependency has been removed.
- Java 1.3 support has been dropped.

GNU/DOS is a FreeDOS distribution.
Main features:
- Several core FreeDOS packages
- The DJGPP development environment with many GNU programs
- The Arachne Web browser and e-mail client
- The OpenGEM graphical user interface with many GEM programs
- The vim editor for developers
- The MTXE screen saver
- GPL, GPL with DJGPP exceptions, vim, Artistic License, Jason Hood License, and LGPL licensed source code for all of the above
GNU/DOS is very well suited for:
- Web and e-mail (no Java or other "plugins") through a dial-up modem (not a "Winmodem") or Ethernet connection
- Classic DOS and console UNIX applications and games
- Development (using the GNU Compiler Collection)
- And more!
Enhancements:
- This release features various updates, bugfixes, and new programs.
- Arachne 1.90 and vim 7.0 were included along with various DJGPP updates and a bootable CD installation option.

Protoscope is a utility that aids Web developers by revealing the HTTP communication in their own applications. It is a nice tool for Web developers who want to "look under the hood" as they develop.

Protoscope is somehow like a HTTP proxy serve and runs like it. It expects to receive HTTP requests from a Web client (such as your Web browser) that is configured to use a proxy.

Note: Most Web browsers allow you to conveniently select a proxy server to use, and the Protoscope Web site will eventually have instructions on how to achieve this for those who need assistance. If you write a HOWTO for configuring a particular browser to use Protoscope, I will gladly link to it. See http://shiflett.org/projects/protoscope/ for more information.

Protoscope forwards the HTTP requests to the origin server just as a proxy would and replies to the Web client with the servers responses. This is all transparent to the Web browser, and it does not affect your browsing in any way.

The difference is that Protoscope logs all communication in the log file that you configure it to use, so that you can examine this log file (or tail it) to examine the HTTP transactions.

In addition, version 0.7.1 added the option to have this information embedded into the HTML document itself. This makes debugging and related tasks extremely efficient while you are developing, and it can even help to avoid having to view source and risk the page being expired from cache or any other annoyances. Simply scroll to the bottom of the page anytime there is a question about the current
transaction. This is the recommended way to use Protoscope.

DTDParse project is a tool for parsing SGML and XML DTDs.

The primary motivation for writing it was to provide a framework for building documentation for DTDs, but other applications are easy to imagine.

Yahoo::Search::Request is a container object for a Yahoo! Search request. (This package is included in, and automatically loaded by, the Yahoo::Search package.)

Package Use

You never need to use this package directly -- it is loaded automatically by Yahoo::Search.

Object Creation

In practice, this class is generally not dealt with explicitly, but rather implicitly via functions in Yahoo::Search such as Query and Links, which build and use a Request object under the hood.

You also have access to the Request object via Request() method of resulting Response and Result objects.

To be clear, Request objects are created by the Request() method of a Search Engine object (Yahoo::Search).

ParaView project is an application designed with the need to visualize large data sets in mind. The goals of the ParaView project include the following:
- Develop an open-source, multi-platform visualization application.
- Support distributed computation models to process large data sets.
- Create an open, flexible, and intuitive user interface.
- Develop an extensible architecture based on open standards.
ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++. Please go here for a detailed list of features.
ParaView was created by Kitware in conjunction with Jim Ahrens of the Advanced Computing Laboratory at Los Alamos National Laboratory (LANL). Contributors and developers of ParaView currently include: Kitware, LANL, Sandia National Laboratories, and Army Research Laboratory. ParaView is funded by the US Department of Energy ASCI Views program as part of a three-year contract awarded to Kitware, Inc. by a consortium of three National Labs - Los Alamos, Sandia, and Livermore. The goal of the project is to develop scalable parallel processing tools with an emphasis on distributed memory implementations. The project includes parallel algorithms, infrastructure, I/O, support, and display devices. One significant feature of the contract is that all software developed is to be delivered open source. Hence ParaView is available as an open-source system.
Main features:
- Handles structured (uniform rectilinear, non-uniform rectilinear, and curvilinear grids), unstructured, polygonal and image data.
- All processing operations (filters) produce datasets. This allows the user to either further process or save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking, and apply glyphs (for example, vector arrows) to the result.
- Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
- Vectors fields can be inspected by applying glyphs (arrows, cones, lines, spheres, and various 2D glyphs) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
- A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
- Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons, etc., and can be processed by a multitude of filters.
- The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for non-linear rectilinear grids).
- With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
- Data can be probed at a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
- ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description (VTK provides hundreds of sources and filters, see VTK documentation for a complete list).
Enhancements:
- This release adds parallel uniform rectilinear grid volume rendering (vtkImageData).
- It introduces new algorithms for parallel unstructured grid volume rendering.
- Support for hardware accelerated offscreen rendering using OpenGL framebuffers.
- Improved multi-block support.
- Improved AMR support.
- Animation saving with ffmpeg.
- Filters have been added for FLUENT, OpenFOAM, MFIX, LSDyna, and AcuSolve.
- A gradient filter for unstructured data.
- Many other enhancements and bugfixes.