Free energy drink software for linux

NeverNoid is an Arkanoid clone. Although there are tons of free games of this type I felt I could do better (Any programmer can second that)

The name NeverNoid is a bit of a wordjoke :) "Nooit" is dutch for "Never" and is pronounced the same way as "Noid". "Never nooit" is also an expression you hear in The Netherlands sometimes and simply means "Never ever".

The game itself hardly needs explanation, but heres some general hints.

NeverNoid features 12 types of powerups/downs.

At some level in the game one or more floaters will enter the game. When hit your ball will instantly change direction. All they do is nag you.

A unique feature is the energy bar. Every time you pick up a powerup (or powerdown) the energy bar charges fully. During play the energy slowly drops and once its depleted your powers go with it.

There are 40 unique maps with 5 levels of difficulty. After playing all maps on a difficulty levels you will start over at a more difficult level. Even though you can choose a new game at only 5 levels the difficulty will keep increasing during gameplay. Thats 200+ levels of fun !

NeverNoid can be played with a mouse or using the keyboard (which makes it more difficult).

Uncle Unc is an application that provides an integrated view of structured data sources. Using a very flexible and powerful representation model, many services can be represented in Uncle Unc.
Uncle Unc is a framework for network data-sharing, enabling remote administration and access to a range of services from a range of clients, using a simple text-based protocol that isnt tied to any platform, operating system or programming language.
Uncle Unc is a toolkit for agile development of interfaces to network services that are easy to maintain, and will grow as the service grows.
At the heart of Uncle Unc is a small generic specification of what a information-based network service might look like. This specification is very generic, and free of reference to any specific technologies or buzz-words.
It is based on the simple observation that much of the time we spend with computers is spent organising and categorising data, pushing data from one box to another, and invoking actions on that data. Most user interfaces attempt to represent this activity for a single type of data, such as a mailbox, a filesystem, a relational database, a network of computers or a music collection. Uncle Unc provides a framework that makes it easy to interact with any data source.
If you feel constrained by the user interfaces you are using (or developing!), or frustrated by having to use a poorly-designed user interface for a particular task, then Uncle Unc may turn out to be a good friend!
Uncle Unc is based on the simple observation that much of the time we spend with computers is spent organising and categorising data, pushing data from one box to another, and invoking actions on that data. Arguably, we ought to spend less time doing this sort of thing and get out into the fresh air more! At the very least, we should be able to do it efficiently and effectively. The more energy we expend on wrestling with the user interface in order to get these low-level jobs done, the less we will have to deal with the high-level problem-solving tasks that can make the difference between work and gainful productivity.
Lets call this low-level categorisation activity as stamp collecting, at the risk of offending philatelists. Most user interfaces attempt to represent stamp-collecting activities for a single type of data, such as a mailbox, a filesystem, a relational database, a network of computers or a music collection. Uncle Unc provides a framework that makes it easy to interact with any data source at this level.By doing it once, we can take the time and effort to do it well, so that it doesnt intrude on the users activities unduly.
Computing is a rapidly changing field, full of powerful new uses for computers such as digital multimedia, realistic graphics and artificial intelligence. And yet much of the time that we use computers, we are performing essentially the same stamp-collecting tasks that we did twenty years ago.
Even when dealing with the new high-powered uses of computers, this is the case. How much of a digital music player programs code is devoted to playing the music, compared to sorting through and organising album playtracks (and which does the user spend most of their time doing?). 3D graphics and neural network designer applications have a similar requirement to present their internal information in a useful way to the end-user.
There is currently little cohesion in the way that software developers address these tasks. Each application codes its own listings widgets. Some have sortable fields. Some have filters. Some can divide the results into pages. Most do some things quite well, some badly, and some not at all. Most will present the interface in a single medium - as a desktop application, or a HTML web interface, a java applet, a flash movie, or whatever. Most will run on a limited number of platforms, Operating Systems or browsers.
This situation restricts the exposure of the application behind the interface, by tying it to that interface. It also limits the exposure of a front-end to a single application. The proverbial wheel is frequently re-invented, and often under tight pressures of time and resources, with less than desirable results.
Uncle Unc is an attempt to develop a generic component framework that allows many different structured data-sorting tasks to be harnessed in a manageable way. A small central set of open interfaces serve as a broker between any client and any service, giving the owners of the network the maximum degree of flexibility. In the language of Desiogn Patterns, Uncle Unc implements a bridge pattern between list-like clients and list-like servers.
Main features:
- A common set of interfaces are provided in the java programming language, and the framework has been developed to make it easy to expose any java object as an Uncle Unc service, and to control what gets exposed and how.
- Network communication between clients and severs is done using XML, opening the door to non-java programs. Over time, we may develop more detailed frameworks for interoperability using PHP, Python, .NET or other popular programming languages.
- Clients and servers are decoupled. That is, a client that can understand one service can understand any service. A service that can talk to one client can talk to any client. This results in a very efficient path to network-enabling a service across a range of platforms, or allowing access to network resources from a new type of client.
- This increases the incentive for developers to provide new capabilities to the system. A widget set that provides a better view of a list of items does so for files, mail, log file entries, databases, newsgroups, etc. without any reworking. Similarly, a new backend service that delivers an Uncle Unc interface will enjoy exposure on all Uncle Unc client platforms (with plans afoot to cover web front-ends, smartphones, and scripting language access as well as the desktop clients).
- The content of the user interface layer is directly defined by the properties and methods of the back-end service. As the back-end service evolves, there is no need to recode the GUI (or other UI), simplky the skeleton used to support it. Even this can be automatically generated from the back-end systems objects. Agile development is supported and encouraged in this way.
- Defining the UI structure directly from the back-end has the further advantage of providing a good fit between the two. A hand-coded UI may omit certain capabilities of the back-end, because they are hard to express using an ad-hoc composition of low-level widgets such as textboxes, tick boxes and drop-down lists.
- The UI is built around an open-ended description of the structure of the service that one is interacting with, rather than expressing a set of fixed pathways of interaction. As such, it supports a flexible, problem-solving approach by the end-user, rather than a purely mechanistic one.

OpenScientist is an integration of open source products working together to do scientific visualization and data analysis, in particular for high energy physics (HEP).
The project is definitely NOT one million lines of intricated and unnecessary complicated home made code reinventing everything.
Motivations
Experiments in high energy and nuclear physics need to be at the edge of computing technologies but at the same time have to face a very long life time (LHC experiments are going to be a matter of decades). This involves that the software must be organized in a way that permits to include or discard some technologies in an easy way without having to recode everything at each change of a piece.
For data analysis, the HEP community had used the CERN/PAW tool for years. Whilst this program had been used and is probably still used by hundred of physicists in the world, it is not any more maintained by the lab that created and promoted it : CERN. This lab had not been able to establish long term collaborative software engineering plans in order to have a technical follow up of this program and analysis tools in general. (What is astounding, is that the same people that were behind CERN/PAW come now with another tool (ROOT) which has exactly the same engineering defects).
OpenScientist is first of all an architecture trying to handle the problem differently to avoid upseting huge software phase transitions in the future. The key points of the system are the modularity and the openness. See the Languages, Coarse graining architecture, and The file formats intrinsic pain section for more about the technical choices and design.
Enhancements:
- An HDF5 driver was introduced in BatchLab.
- The build system was replaced with obuild.
- Support for CoinPython was added.
- Initial support was added for both Qt4 and SDL.
- Examples were added.
- Assorted code cleanups and speedups were done.

dimnum is a C++ template library for dimensional numbers.

The dimnum C++ library provides templated classes for storage of dimensional numbers, like lengths, masses, and so on. The classes are templated over the storage data type, and the base unit.

Output as well as input (with automatic recognition of the base unit) through standard C++ streams is supported. The dimension information is handled completely at compile time, so no additional memory is required for storage.

In both dimnum and SIunits, numbers are represented in a given base (ie. you can for instance declare a length object which is expressed in meters). In SIunits this base unit ("one meter") is fixed at compile time (ie. all values are represented in meters), while in dimnum it is a template parameter. In dimnum you can have (in one program) both values expressed in the SI basis and in, for instance, the British foot/inch/... basis, while in SIunits you have to make a choice.

Dimnum uses a different treatment of models in which dimensions merge (for instance the high energy physics model, in which the speed of light and Plancks constant are put equal to one). In dimnum models can be mixed, in SIunits you have to choose one.

Treatment of I/O differs (dimnums method uses more static data where SIunits uses dynamical switches); a bit hard to explain in one or two lines.

Dimnums actual code (i.e. excluding the constant lists and the dimensionful number declarations) is also a bit smaller.

SBaGen generates sounds that give an altered state of consciousness. The theory behind binaural beats is that if you apply slightly different frequency sine waves to each ear, a beating affect is created in the brain itself, due to the brains internal wiring.
If, in the presence of these tones, you relax and let your mind go, your mind will naturally synchronize with the beat frequency. In this way it is possible to tune the frequency of your brain waves to particular frequencies that you have selected, using of the four bands: Delta: deep sleep, Theta: dreaming and intuitive stuff, Alpha: awake, focussed inside, and Beta: awake, focussed outside.
It is also possible to produce mixtures of brain waves of different frequencies by mixing binaural tones, and in this way, with practice and experimentation, it is reportedly possible to achieve rather unusual states, such as out-of-body stuff, and more. See the books by Ken Eagle Feather, and the Monroe Institute site for more details. The Monroe Institute have apparently put 40 years of research into these techniques.
Centerpointe have also done a great deal of research into binaural beats, concentrating more on improving overall well-being and holistic functioning rather than reaching unusual states, and I recommend reading some of the articles on their site (look under "Site Map", for example their Special Report: "How The Holosync Technology Works" and their FAQ).
I should add that I have only read about the more advanced and unusual uses (OOBEs and so on). My own experiences have not reached quite that far, but still I feel that I have benefitted immensely from using these techniques over the last few years: from simply getting my head clear in confusing moments, to the energy boosts that come at times, to more general emotional clearing, and occasional very intense dreams (although not quite lucid).
So, SBAGEN is my utility, released as free software (under the GNU General Public Licence) for Linux, Windows, DOS and Mac OS X, that generates binaural tones in real-time according to a 24-hour programmed sequence read from a file. It can also be used to play a sequence on demand, rather than according to the clock, or to write a WAV file for playing later. Pink noise, MP3 and Ogg files (since version 1.2.0) may also be mixed with the binaural beats to provide background sounds. (Two files of randomly-looping river sounds are provided from version 1.4.0 onwards). This tool is ideal for anyone who wishes to experiment with these techniques and do research into this for themselves. (For those who would rather pay for a pre-packaged programme with support, I recommend taking a look at the Centerpointe site -- and see my disclaimer)
My original idea was to use this utility to play a programme of different tones throughout the night, hoping to improve dreaming and dream-recall, and then to bring myself up into Alpha rhythms to (hopefully) make a good start to the day. I am now using it more for shorter focussed sessions of about an hour, both during daytime and at night. However, other people have used this software in many different ways. For example, one person suffering constant pain from historical injuries appreciated the way that he could tune the frequencies very accurately to his needs to help him sleep better at night. Other more unusual uses have included: mixing the sounds in as part of musical compositions, and generating ambient sounds during live DJ sets or trance music.
Enhancements:
- Fixed problem when playing 7+ hour sequences with -SE or -L
- Warns properly if the WAV file limit of ~7 hours is exceeded, and truncates

Template::Recall is a "Reverse callback" templating system.



SYNOPSIS

use Template::Recall;

my $tr = Template::Recall->new( template_path => /path/to/template/sections );

my @prods = (
soda,sugary goodness,$.99,
energy drink,jittery goodness,$1.99,
green tea,wholesome goodness,$1.59
);

$tr->render(header);

# Load template into memory

$tr->preload(prodrow);

for (@prods)
{
my %h;
my @a = split(/,/, $_);

$h{product} = $a[0];
$h{description} = $a[1];
$h{price} = $a[2];

print $tr->render(prodrow, %h);
}

# Remove template from memory

$tr->unload(prodrows);

print $tr->render(footer);

Template::Recall works using what I call a "reverse callback" approach. A "callback" templating system (i.e. Mason, Apache::ASP) generally includes template markup and code in the same file. The template "calls" out to the code where needed. Template::Recall works in reverse. Rather than inserting code inside the template, the template remains separate, but broken into sections. The sections are called from within the code at the appropriate times.