Free chronic constipation symptoms software for linux

Causes and Symptoms program helps you deduce the causes causes of your medical symptoms that may be related to nutritional deficiencies.

Hackystat is a framework for the automated collection and analysis of software engineering product and process data.
Hackystat uses sensors to unobtrusively collect data from development environment tools; there is no chronic overhead on developers to collect product and process data. Hackystat does not tie you to a particular tool, environment, process, or application.
Hackystat project is intended to provide in-process project management support.
Hackystat is in its sixth major architectural release family. The first architectural release family, called the "Spike Solution", was used to explore the feasibility of the approach and to evaluate various component technologies (including JATO, XSL, Ant, JUnit/HttpUnit, Tomcat, Cocoon, and SOAP). Work on this Spike Solution architecture lasted eight months, from May to December, 2001.
In December 2001, we began a major re-implementation of the system in order to provide architectural support for design discoveries made with the Spike Solution. This second architectural release family is called the "Framework Architecture", because it implements package and class-level patterns that facilitate extension of the system via inheritance and composition of existing classes. Unfortunately, the Framework architecture required modification of the hackystat source code to implement new sensors and analysis, and only a single configuration of analyses and sensors can be supported in this architecture.
In November, 2002, we began work on the "SDK" (or "kernelized") architecture release family. This third architectural family decomposes the system into two layers. The first layer is a kernel system which implements the core facilities for data definition, storage, transmission and user interface.
Developers build an actual Hackystat installation by combining the framework with a second layer: a set of plug-in extension modules that define the specific sensor data types, tool sensors, and analyses required to support their development procedures. In the SDK architecture, developers can implement new sensors and analyses without modifying the underlying kernel code, and multiple Hackystat installations can be built with different configurations of analyses and sensors.
In June, 2003, we performed a package restructuring that facilitates the development of third layer, or "application" layer systems. This is the fourth architectural release family, called the "Three Layer" architecture.
After only a month of application layer development, we realized that the build process we developed for the second release family would be woefully inadequate to support the three layer architecture, in which multiple components would be combined into a configuration for release.
So, in August, 2003, we released the fifth architectural release family, called the "Component Architecture", along with extensive new build support including the hackydev web site with daily integration builds.
In July, 2004, we released the sixth architectural family, which provides services to support a "telemetry" based approach to software project monitoring and control. This includes various caching mechanisms, as well as the hackyTelemetry package that includes a telemetry specification language and associated APIs. In this architecture, telemetry support becomes a "low level" feature of the system.
Enhancements:
- A new sensor for IntelliJ Idea, enhancements to the Visual Studio sensor, improved support for test driven development inference, and many bugfixes.

AxKit2::Transformer::XSP Perl module contains eXtensible Server Pages.

SYNOPSIS

< xsp:page
xmlns:xsp="http://apache.org/xsp/core/v1" >

< xsp:structure >
< xsp:import >Time::Piece< /xsp:import >
< /xsp:structure >

< page >
< title >XSP Test< /title >
< para >
Hello World!
< /para >
< para >
Good
< xsp:logic >
if (localtime->hour >= 12) {
< xsp:content >Afternoon< /xsp:content >
}
else {
< xsp:content >Morning< /xsp:content >
}
< /xsp:logic >
< /para >
< /page >

< /xsp:page >

XSP implements a tag-based dynamic language that allows you to develop your own tags, examples include sendmail and sql taglibs. It is AxKits way of providing an environment for dynamic pages. XSP is originally part of the Apache Cocoon project, and so you will see some Apache namespaces used in XSP.

Also, use only one XSP processor in a pipeline. XSP is powerful enough that you should only need one stage, and this implementation allows only one stage. If you have two XSP processors, perhaps in a pipeline that looks like:

... => XSP => XSLT => XSLT => XSP => ...

it is pretty likely that the functionality of the intermediate XSLT stages can be factored in to either upstream or downstream XSLT:

... => XSLT => XSP => XSLT => ...

This design is likely to lead to a clearer and more maintainable implementation, if only because generating code, especially embedded Perl code, in one XSP processor and consuming it in another is often confusing and even more often a symptom of misdesign.

Likewise, you may want to lean towards using Perl taglib modules instead of upstream XSLT "LogicSheets". Upstream XSLT LogicSheets work fine, mind you, but using Perl taglib modules results in a simpler pipeline, simpler configuration (just load the taglib modules in httpd.conf, no need to have the correct LogicSheet XSLT page included whereever you need that taglib), a more flexible coding environment, the ability to pretest your taglibs before installing them on a server, and better isolation of interface (the taglib API) and implementation (the Perl module behind it). LogicSheets work, and can be useful, but are often the long way home. That said, people used to the Cocoon environment may prefer them.

Result Code

You can specify the result code of the request in two ways. Both actions go inside a < xsp:logic > tag.

If you want to completely abort the current request, throw an exception:

throw Apache::AxKit::Exception::Retval(return_code => FORBIDDEN);

If you want to send your page but have a custom result code, return it:

return FORBIDDEN;

In that case, only the part of the document that was processed so far gets sent/processed further.

Debugging

If you have PerlTidy installed (get it from http://perltidy.sourceforge.net), the compiled XSP scripts can be formatted nicely to spot errors easier. Enable AxDebugTidy for this, but be warned that reformatting is quite slow, it can take 20 seconds or more on each XSP run for large scripts.

If you enable AxTraceIntermediate, your script will be dumped alongside the other intermediate files, with an extension of ".XSP". These are unnumbered, thus only get one dump per request. If you have more than one XSP run in a single request, the last one will overwrite the dumps of earlier runs.

Fenris is a suite of tools suitable for code analysis, debugging, protocol analysis, reverse engineering, forensics, diagnostics, security audits, vulnerability research and many other purposes.
The main logical components are:
- Fenris: high-level tracer, a tool that detects the logic used in C programs to find and classify functions, logic program structure, calls, buffers, interaction with system and libraries, I/O and many other structures. Fenris is mostly a "whats inside" tracer, as opposed to ltrace or strace, tracers intended to inspect external "symptoms" of the internal program structure. Fenris does not depend on libbfd for accessing ELF structures, and thus is much more robust when dealing with "anti-debugging" code.
- libfnprints and dress: fingerprinting code that can be used to detect library functions embedded inside a static application, even without symbols, to make code analysis simplier; this functionality is both embedded in other components and available as a standalone tool that adds symtab to ELF binaries and can be used with any debugger or disassembler.
- Aegir: an interactive gdb-alike debugger with modular capabilities, instruction by instruction and breakpoint to breakpoint execution, and real-time access to all the goods offered by Fenris, such as high-level information about memory objects or logical code structure.
- nc-aegir: a SoftICE-alike GUI for Aegir, with automatic register, memory and code views, integrated Fenris output, and automatic Fenris control (now under development).
- Ragnarok: a visualisation tool for Fenris that delivers browsable information about many different aspects of program execution - code flow, function calls, memory object life, I/O, etc (to be redesigned using OpenDX or a similar data exploration interface).
- ...and some other companion utilities.
Code analysis is not limited to debugging, quality assurance or security audits. Understanding and handling file formats or communication protocols used by proprietary solutions, a problem that many corporations face when they decide to change their base software platform from one, obsolete or insufficient solution to another, perhaps more suitable, is a task that can consume long months and millions of dollars, especially when any misjudgment or misinterpretation is made.
Because of that, accurate and complete information about existing solutions has to be obtained and evaluated in a timely manner. This project is an attempt to fill the gap between currently used tools by providing a freely available program analysis utility, suitable for black-box code audits, algorithm analysis,
rapid reconnaissance in open-source projects, tracking down bugs, evaluating security subsystems, performing computer forensics, etc.
This program does not automate the process of auditing, and does not favor any particular use. Instead of that, it is intended to be a flexible and universal application that will be a valuable solution for many advanced users. While functional, it is probably not tested sufficiently, there are many issues to fix, several known bugs, some portability problems.
It is being released primarily to get user feedback, comments, and, most important, to request development support, as my resources are very limited, both in terms of available time and development platforms. This project is and will be distributed as a free software, regardless of projected use, accompanied by complete sources, under the terms and
conditions of GPL. Why do you might need this code? Well, there are few reasons...
Human beings are, so far, the best code analysts. Unlike computer programs, they have imagination, ability to build synthetic abstract models, and yet to observe and analyze smallest details at the same time. Functionality is often being described as "doing what the program is supposed to do", security as "doing what the program is supposed to do and
nothing more". While it might sound funny, that is the most general and complete definition we have. In most real-life scenarios only humans really know what are their expectations. Building strict formal models of our expectations does not necessarily mean that models themselves are flawless, and is very time-consuming. Then, even with such models,
validating the code is not always possible, due to its computational complexity. That is why real, live programs (not including some critical developments) do not have such models, do not follow any particular coding guidelines, and cannot be formally examined without human judgment.
Unfortunately, humans are also highly inaccurate and very expensive. They work slowly, and better results can be achieved by hiring better specialists and performing more careful audit. And after all, even the best expert can overlook something in complex, hard to read code. It is almost impossible for human to perform an accurate audit of a large, complex, heterogeneous project written e.g. in C - like Sendmail, BIND, Apache - and provide results in reasonable time.
Things get even worse when humans try to understand algorithms and protocols used by complex closed-source black box solutions. They are simply too slow, and not always able to make accurate guesses about dozens of complicated, conditional parameter passes and function calls before final action is taken.
While it might sound surprising, human-driven code audit is very similar to playing chess - it is a general analysis of possible states, way too many to be implicitly projected by our conscience, a result of experience, knowledge, some unparalleled capabilities of human brain, and luck. It is also a subject to false moves and misjudgment. And there are maybe just a few hundred excellent players.
As for today, freely and commercially available audit tools both use two opposite approaches. First approach tends to minimize human role by automating the review of source code. Source code analysis methods are good in spotting known, repeatable static errors in the code - such as format string vulnerabilities. On the other hand, static tools are not able to trace and analyze all possible execution paths of complex application by
simply looking at its source.
The reason for inability to follow all execution paths lies deeply in the foundations of modern computation theory, and one of its aspects is known as "the halting problem". Speaking in more general terms, in many cases (such as complex software, or even underlying operating system), the amount of medium needed to store all possible states of a complex program exceeds significantly the number of particles in the
universe; and the amount of time needed to generate and process them sequentially is greater than the lifetime of our universe, even having a machine that works with the speed of light.
This might be changed by the development of new computation models, such as quantum computing, or by creating mathematical models that allow us to make such problems non-polynomial - but for now, we are far from this point, and static analysis is restrained in many very serious ways, even though many software suppliers tend to market their products as the ultimate, 100% solutions. Subtle, complex, conditional dynamic errors, such as privilege dropping problems, input-dependent table overflows in C and many other issues usually cannot be detected without generating a completely unacceptable number of false positives.
This kind of software is highly dependent on coding style, and specific notation or development practices might render them less efficient - for example, automated audit utilities can usually detect problems like insecure call to strcpy() function, but will very likely not notice insecure manual copy in do-while
loop. The truth is, for programs that do not have previously built formal models, static auditing utilities look for known, common problems in known, common types of code in a very limited scope.
Another issue is the applicability of this approach to algorithm analysis tasks. In the domain of automated audit tools, this problem is "reduced" to building a formal model of program behavior, or, more appropriately, generating certain predictive statements about the code. While there are very interesting developments in this direction, such as the work of professor Patrick Cousot, it is very difficult to make any detailed, accurate and abstract enough run-time predictions for complex source code that has any immediate value in the analysis of unknown algorithm.
Last but not least, static analysis of sources can be deployed only when the source code is available, which does not have to be the case. This approach is a subject to many shortcomings, tricky assertions, and is a technique of strictly limited capabilities. This is, of course, not to dismiss this method - but to demonstrate that this much favored approach is not flawless and how much it needs to be accompanied with auxiliary methods.
The second approach to be discussed here is based on a dynamic run-time program analysis. This method is usually used to provide the user with information about actual program execution path, letting him make decisions on which path to follow and giving him free will to draw any conclusions and perform all the synthetic reasoning.
This method is
applied to a live binary executed in real-time and is based on monitoring syscalls (strace), libcalls (ltrace) or functions (xtrace); in certain cases, breakpoint debuggers, such as gdb, can be used, however it is usually not feasible to use them to perform anything more than in-depth analysis of a very small portion of program functionality. Usually, such analysis provides a very useful information on what is happening, and this information is provided in uniform, reduced-output form.
A careful auditor can analyze program behavior and find interesting or potentially dangerous run-time conditions. By monitoring how a given application interacts with external world, he (or she) can determine whether some other
conditions can be triggered and eventually explore them by examining sources or re-running the program. Advantages are enormous, as such software enables the auditor to spot very subtle errors in code that "looked good", to observe actual execution, not to try to figure it out, and to find or trace down not obvious or non-schematic vulnerabilities. Run-time trace tools are primarily used for fast reconnaissance tasks and for tracing down notorious errors that are not clearly visible in the source, significantly reducing the time of such operations.
There are, however, serious drawbacks related to this method. First of all, known tracing tools do not provide the complete information. They will detect strcpy() call, but wont report if exactly the same functionality has been implemented from scratch by the author of given program. And, in some cases, the amount of produced data
can be enormous, and because of its completely unstructured character, it makes the observation of overall execution vector almost impossible. Two most important problems are: correlating trace data with actual code, and determining what occurred in the "dark matter" between two lines of trace output.
There are some attempts to combine both approaches - run-time evaluation and source code analysis - such as Purify or many other commercial development support products. Unfortunately, they all feature a limited set of capabilities that need development-side or compilation-time support and are not really suitable for comprehending black box solutions or performing a general analysis. Most of them are targeted for dynamic memory debugging and code / memory profiling.
While not mentioned above, there is also another approach to black-box code - high-level decompiler. However, the complexity of modern compilers makes it very difficult to develop an effective C decompiler or similar utility, and there are only a few (two?) projects available to accomplish it, all of them not able to deal with too complex or optimized code. Finally, there is no guarantee that generated output code will be any help in comprehending the program. For now, this approach remains almost purely theoretical,
and I am not aware of any auditors using it extensively. Why? Well, heres an example of decompiled, mildly optimized code *with* some symbolic information: http://www.backerstreet.com/rec/ex386/hdgO.rec . One may argue it is less readable than cross-referenced disassembly.
This project, Fenris, is named after the monstrous wolf, son of the Norse god Loki. It is not the ultimate answer to all questions, not a solution for all problems, and under no circumstances is intended to replace other tools and techniques. On the other hand, it makes one step forward compared to other tools, trying to support the auditor and to make his work much more effective. This is accomplished by combining a number of techniques, including partial run-time decompiler, stateful analysis, code fingerprinting, I/O analysis, high-level visualization layer, traditional interactive debugger features and run-time code modification capabilities. The goal is to provide a very detailed trace information, and, at the same time, to provide data suitable to build a model of program behavior more quickly and in more convenient way.
Fenris is not supposed to find vulnerabilities or bugs, or to guess algorithms or describe protocols. It is supposed to report and analyze the execution path - detect and describe functional blocks, monitor data flow in the program, marking its lifetime, source, migration and destination, analyze how functions work and what conditions are evaluated.
At the end, it can deliver you an execution model of traced program (or arbitrarily chosen portion of it, if complete trace results in too much noise or irrelevant information), and hint you how this model can change in different conditions. Fenris does not need source codes of analyzed application, but obviously does not keep the auditor from using them.
For many users, Fenris might be a new tool or tools, for others - just a command-line replacement or addition to strace, ltrace, gdb or similar applications (theres a brief list of other nice tools in doc/other.txt). And thats the idea - to build a tool that is simple, reusable, but also precise and smart. It is supposed to have advantages over other tools, but not to be an ultimate replacement or the final solution. Some users can just use very specific features, such as automated function fingerprinting, and use companion tools instead of the main program.

Pie is a lightweight content management system for Web-sharing documents, files, and arbitrary pieces of information.
Pie is just another web-based content composition and management environment using the idea of collaborate editing and sharing, an idea that has been taken to great extends lately by a crusade called Wiki.
Although so-called content management systems existed long before, employing both, proprietary as well as standardized means, the Wiki mythos pushed this effort even farther.
As with XML, another internet hype, and one that is still based many illusions upon (careless marketing strategists and clueless mortals have conventionalized XML to be one of those black magic three-letter acronyms that, if inhaled properly, is able to cook coffee, change your kids nappies and, all things considered, makes you a better human being once youve accepted it and freely offer it your untainted soul), Wikis more and more come to the publics attention and you clearly classify yourself as an outsider if you do not embrace the new technologys blessing.
A projects or ideas popularity shares its symptoms with economic growth: once it is unleashed upon the populace, grapping and holding their and all bystanders attention, it can not be stopped anymore until, of course, the climax is reached and everyone turns away, bored to death.
Nevertheless, Pie is another attempt to bore people willing to pay attention, offering its services freely and obendiently to those who are willing to accept them.
Pie has been designed to be tasty and can be served with a variety of ingredients. Basically, it serves you by gladly feeding upon your mental output, this being mostly text, but also graphics, music, programs and other intellectual property.
Before you build up your illusions right away, at the very start, it should be mentioned that Pie is unable to cook coffee. This fact cannot be stressed and overemphasized enough. Being a content management system, Pie does lots of things for you, but it certainly cant cook coffee.
If this was one of your basic requirements, you may cut off here, right now, and go for a secretary instead. (Hopefully, you didnt take this barking of your shin too seriously. Yet, it might have saved you a lot of time, if properly prepared coffee really was what you were looking for.)
Imagine, just for a moment, that youd like to collect your thoughts, on any conceivable matter. You could handle this the conventional way by writing them down in your diary. Still, you are a modern person, always having preferred to employ technology whereever you can.
Consequently, you foreclosed, of course, to make use or your PCs text processing features, thus being able to edit, cut and paste, and move around and modify your text in whatever manner and as often as you like.
Let us take this scenario one step farther: you not only want to be able to manage your thoughts at home or at work, but virtually everywhere and anytime. Sure, you can use a laptop for this purpose. However, being a social being, you want others to participate and take in (or even contribute to) your ideas - again, anytime and everywhere, as long as the participants have access to moderate 20s century technology.
You may send your data and files back and forth, using e-mail, or you could even rely on more sophisicated technology, like CVS, or you could make use of your proprietary publishing softwares distributed auto-update feature to spread your latest thoughts to remote clients, the participants, anywhere in the Net. Alternatively, you might rely on one of the Nets most accepted means: the Web.
Doing so, not only enables you to refrain from ugly, expensive, proprietary software, but also connects you, and those with whom you intend to share your intellectual propery, using a simple, standardized means.
Main features:
- Quick page processing and short run-time latency
- Low system requirements (both, in regard of the running servers performance as well as the complexity of the installed software base)
- Independent of ODBC, SQL and other database systems, both, session-based and file-based
- Multi-user support
- Page locking
- Browsable and revertable page versioning
- Local link/referer verification
- Optional (semi-)automatic page expiration
- Customizable PCRE-patterns for pages and files
- A rather extensive user manual
- Localized user interface
- Optional directory hashing to handle large amounts of files
- Small and simple code library
- Easily adaptable and extendable to personal needs
- Weighs less than 200 blocks (i. e. 100 KB), including online documentation
- Supports many common HTML directives, including tables
- XHTML 1.0 clean output
- Peachy
Enhancements:
- The code library has been completely rewritten, focusing on extendability and abstraction.
- All low-level functions have been implemented as OO classes.
- Both pages and files support an arbitrary number of versions, limited only by the capacity of the underlying file system.
- Usability has been improved.
- Most operations are selectable from drop-down menus via mouse clicks or Editing Mode.
- Editing has been fine-tuned.
- Text can be marked and, by clicking a button, applied various markup properties.

Apache::AxKit::Language::XSP is a Perl module with eXtensible Server Pages.

SYNOPSIS

< xsp:page
xmlns:xsp="http://apache.org/xsp/core/v1" >

< xsp:structure >
< xsp:import >Time::Object< /xsp:import >
< /xsp:structure >

< page >
< title >XSP Test< /title >
< para >
Hello World!
< /para >
< para >
Good
< xsp:logic >
if (localtime->hour >= 12) {
< xsp:content >Afternoon< /xsp:content >
}
else {
< xsp:content >Morning< /xsp:content >
}
< /xsp:logic >
< /para >
< /page >

< /xsp:page >

XSP implements a tag-based dynamic language that allows you to develop your own tags, examples include sendmail and sql taglibs. It is AxKits way of providing an environment for dynamic pages. XSP is originally part of the Apache Cocoon project, and so you will see some Apache namespaces used in XSP.

Also, use only one XSP processor in a pipeline. XSP is powerful enough that you should only need one stage, and this implementation allows only one stage. If you have two XSP processors, perhaps in a pipeline that looks like:

... => XSP => XSLT => XSLT => XSP => ...

it is pretty likely that the functionality of the intermediate XSLT stages can be factored in to either upstream or downstream XSLT:

... => XSLT => XSP => XSLT => ...

This design is likely to lead to a clearer and more maintainable implementation, if only because generating code, especially embedded Perl code, in one XSP processor and consuming it in another is often confusing and even more often a symptom of misdesign.

Likewise, you may want to lean towards using Perl taglib modules instead of upstream XSLT "LogicSheets". Upstream XSLT LogicSheets work fine, mind you, but using Perl taglib modules results in a simpler pipeline, simpler configuration (just load the taglib modules in httpd.conf, no need to have the correct LogicSheet XSLT page included whereever you need that taglib), a more flexible coding environment, the ability to pretest your taglibs before installing them on a server, and better isolation of interface (the taglib API) and implementation (the Perl module behind it). LogicSheets work, and can be useful, but are often the long way home. That said, people used to the Cocoon environment may prefer them.

UMLMON is a complete run time environment for User Mode Linux. There is a separate monitor daemon for every VM.
UMLMON project creates the run time environment and starts the VM by executing the UML kernel. The daemon also determines the arguments that are passed to the UML kernel, and includes special support to set up arguments for memory size, virtual disks, virtual network interfaces, and console channels in a convenient way.
UMLMON also includes routines to do certain administration tasks like the creation of disks.
The team UMLMON + UML can be applied in the following areas:
- Server consolidation: Improve the utilization of server hardware, and ease the operation of servers.
- Virtual security zones: Instead of building demilitarized zones (DMZ) with real hardware, it is a cost-effective alternative to set up purely virtual DMZs on a single host.
- Virtual hosting: A cheap version of server hosting is virtual hosting; instead of leasing real computers to customers, virtual machines are used.
- Laboratory nets: By using virtual machines it is possible to build cheap laboratory nets, e.g. to test software in real network environments.
- Training environments: One can use virtual machines for Linux trainings where participants can get true administrators priviledges without any risks.
Enhancements:
- This release no longer call the problematic glibc function getgrouplist, which is often broken (symptom: segmentation fault immediately after starting umlmon).