Free encryption programming software for linux

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Eureka Encryption Global Edition contains file encryption, multiple encryption, merge encryption, multiple file encryption, embedded applications (Crypt Words, Steganographer, Interface) and other tools such as a file shredder and scrambler.

Eureka Encryption Global Edition is available for Windows, Mac and Linux. Other applications are available from the website.

AFNIX is a multi-threaded functional programming language with dynamic symbol bindings that support the object oriented paradigm. AFNIX programming language features a state of the art runtime engine that supports both 32 and 64 bits platforms.
AFNIX is distributed with several clients and a rich set of libraries that are designed to be platform independent. For a short description, you can look at the contents or for a short introduction, you can look at the tutorial.
A flexible license has been designed for both individuals and corporations. Everybody is encouraged to use, distribute and/or modify the AFNIX engine for any purpose. You can register on our mailing list. We issue news once a month. Your email address is covered by our strict privacy policy.
AFNIX is a powerful engine associated with a rich set of libraries. The interpreter is written in C++. Its modular architecture makes the installation and maintenance an easy task.
AFNIX has a rich syntax which make the functional programming a pleasant activity. AFNIX is ready for use on various UNIX platforms. A rich documentation is also provided as a guide and reference material.
Enhancements:
- This is a minor release that fixes the build process with GCC 4.2.

2E Programming Language (two es, as in ee, or expression evaluator) is a simple algebraic syntax language. It natively supports expressions (composed of operators and operands), and function definitions, and basically nothing else. Therefore, it can be fairly straight-forward to learn (assuming you are already familiar with general programming constructs).
The language itself is refered to as 2e, however the interpreter is called ee.
An operand can be a literal, such as a numeric value (integer or floating point), a quoted string, a single-quoted character, a variable or a function call. Operators consist of the standard algebraic operators (i.e., *, /, +, -), assignment ("="), logical operators (, =, ==), sub-expression join operator (";"), and a conditional operator pair ("? :") like in C. Also added, is an iterative conditional pair ("?? :").
Heres a couple of examples:
ee -p 2 + 3 * 7
23
In this case, when called with the "-p" flag, the next parameter is evaluated and the final result printed. The "-c" flag does the same thing, but doesnt print the final result (use this when the expression already contains output statements).
ee -c x = 7; y = 11; z = (x * y); print(z; "n")
77
The ";" operator isnt really a statement terminator, it is actually a join operator. It evaluates the left and right expressions, and returns the result of the right hand side. It has the lowest order of precedence, so in general use you can treat it like a statement terminator (however it can be used in the middle of a larger expression, such as within parentheses grouping). It also does double-duty as a function parameter delimeter, such as the print function in the previous example.
The way that the "?" (conditoinal) operator works is as follows:
result = expr_test ? expr_true : expr_false
If expr_test is true (non-zero), then expr_true is evaluated and returned, otherwise expr_false is evaluated and returned. This is just like the inline conditional in C.
Also supported, is the iterative conditional:
result = expr_test ?? expr_true : expr_false
This will evaluate expr_test repeatedly, and as long as it is true, will evaluate expr_true. Once expr_test becomes false, then the final expr_true value is returned as the result of the whole expression. However, if expr_test never was true to begin with, then and only then is expr_false evaluated and returned. Therefore, expr_false can be used for some error handling, for example.
If an operator of lower precedence than ? or ?? is encounterd such as the ";" (join) operator, then a default false target will automatically be assumed. Therefore,
result = expr_test ? expr_true : 0; ...
result = expr_test ? expr_true; ...
are both the same. Heres a more extensive example, highlighting a few more of the operands avaliable. This example also calls the interpreter using the unix "#!" syntax, same as what is used for other scripting languages.
#!/usr/local/bin/ee
# This is a comment
i = 0;
x = 0;
i < 10 ?? ( # Read this as "while i is less than 10"
j = 0;
j < 5 ?? ( # while j < 5
array[i][j] = x; # here we are assigning a value to a 2-dimentional array
j++;
x++
);
i++
)
This example uses the iterative conditional operator to initialize an array. Notice the missing ";" after x++ and i++. this is because they are not followed by an operand (instead, in this case are followed by a closing parenthese). The ";" operator is a binary operator, no different than +, -, *, /, etc. Therefore, it is only used between to operands or two sub-expressions.
Enhancements:
- This release adds a bunch of functions to round out the string handling capabilities of 2e.
- Also added are "anonymous" functions, bitwise operators, and a few code cleanups.

Intro to Bash Programming HOWTO is a bash programming tutorial.
The Intro to Bash Programming HOWTO is meant for newbies who wish to learn how to write shell scripts for bash, the GNU Boure-Again shell.
It contains several samples. It is very early in its development, but it is hoped that some people might find it useful.
Enhancements:
- New translations included and minor correcitons.

AJAX is all the rage these days, and for a good reason. With AJAX, you can create web applications with nearly the same functionality as your desktop programs. Super AJAX Programming Seed project is a tight script that illustrates a simple use of AJAX technology using PHP, HTML and JavaScript.
Main features:
- Super AJAX Programming Seed is easy to install. Just upload the files to your server and youre good to go.
- Super simple code makes it easy to start using AJAX in your own applications.
- Comes with a working exaple of AJAX so you can get started right away.
- Use Super AJAX Programming Seed as a starter for your own technology, or offer it as an example on your own web site of AJAX in action.

Qore is a modular, multi-threaded, SQL-integrated, weakly- typed scripting language with procedural and object-oriented features, powerful and easy-to-use data types, structures, and operators, and a clean and easy-to-learn/read syntax.
Qore Programming Language features Oracle and MySQL DBI drivers, optional TIBCO AE integration, and easy date arithmetic, is very scalable on SMP systems, and much more.
Enhancements:
- 3 new DBI drivers, PostgreSQL, Sybase, and FreeTDS ("pgsql", "sybase", "mssql")
- more support for database and driver-independent programming
- new DatasourcePool class for transparent Datasource connection pooling
- HTTPClient improvements (redirections, basic authentication, proxy support)
- safe signal handling
- complete deadlock detection and thread primitive error handling
- all thread locking primitives now take an optional timeout value
- call references (including object method references that will be executed in the context of the object referenced)
- mysql and oracle driver improvements
- extensive enhancements for exception-safe programming (on_exit, on_error, on_success statements, new classes, etc)
- significant performance improvements
- tibae module improvements
- many new functions and methods, bug fixes, extensive documentation updates, etc