Ports Search

Celluloid::IO provides an event-driven IO system for building fast, scalable network applications that integrates directly with the Celluloid actor library, making it easy to combine both threaded and evented concepts. Celluloid::IO is ideal for servers which handle large numbers of mostly-idle connections, such as Websocket servers or chat/messaging systems. Celluloid::IO provides a different class of actor: one that's slightly slower and heavier than standard Celluloid actors, but one which contains a high-performance reactor just like EventMachine or Cool.io. This means Celluloid::IO actors have the power of both Celluloid actors and evented I/O loops. Unlike certain other evented I/O systems which limit you to a single event loop per process, Celluloid::IO lets you make as many actors as you want, system resources permitting. Rather than callbacks, Celluloid::IO exposes a synchronous API built on duck types of Ruby's own IO classes, such as TCPServer and TCPSocket. These classes work identically to their core Ruby counterparts, but in the scope of Celluloid::IO actors provide "evented" performance. Since they're drop-in replacements for the standard classes, there's no need to rewrite every library just to take advantage of Celluloid::IO's event loop and you can freely switch between evented and blocking IO even over the lifetime of a single connection.

Ur is a programming language in the tradition of ML and Haskell, but featuring a significantly richer type system. Ur is functional, pure, statically-typed, and strict. Ur supports a powerful kind of metaprogramming based on row types. Ur/Web is Ur plus a special standard library and associated rules for parsing and optimization. Ur/Web supports construction of dynamic web applications backed by SQL databases. The signature of the standard library is such that well-typed Ur/Web programs "don't go wrong" in a very broad sense. Not only do they not crash during particular page generations, but they also may not: * Suffer from any kinds of code-injection attacks * Return invalid HTML * Contain dead intra-application links * Have mismatches between HTML forms and the fields expected by their handlers * Include client-side code that makes incorrect assumptions about the "AJAX"-style services that the remote web server provides * Attempt invalid SQL queries * Use improper marshaling or unmarshaling in communication with SQL databases or between browsers and web servers

exmh is a TCL/TK based interface to the MH mail system. It provides the usual layer on top of MH commands, as well as many other features: MIME support! Displays richtext and enriched directly. Color feedback in the scan listing. A colour coded folder display with one label per folder. Smart scan caching. News read/post. koi8-r support. Facesaver bitmap display. Ispell support. Background inc. You can set exmh to run inc periodically. Searching over folder listing and message body. A dialog-box interface to MH pick. An editor with emacs-like bindings and MIME support. Glimpse interface. You can index all your mail with glimpse and search for messages by content. User preferences. You can tune exmh through a dialog box. User hacking support. A user library of TCL routines is supported. IMPORTANT: exmh depends on the TK send facility for its background processing. With TK 3.3, send now uses xauthority mechanisms by default, unless you compile TK with -DTK_NO_SECURITY. Generally, this means that you **MUST** must run xdm to start your Xserver.

Preppy is ReportLab's templating system. It was developed in late 2000 and has been in continual production use since then. It is open source (BSD-license). The key features are: - *small*. Preppy is a single Python module. If you want a templating system 'in the box', it's easy to include it in your project - *easy to learn*. It takes about one minute to scan all the features - *just Python*. We have not invented another language, and if you want to do something - includes, quoting, filters - you just use Python - *compiled to bytecode*: a .prep file gets compiled to a Python function in a .pyc file - *easy to debug*: preppy generates proper Python exceptions, with the correct line numbers for the .prep file. You can follow tracebacks from Python script to Preppy template and back, through multiple includes - *easy to type and read*. We've been using ``{{this}}`` syntax since well before Django was thought of - *8-bit safe*: it makes no assumption that you are generating markup and does nothing unexpected with whitespace; you could use it to generate images or binary files if you wanted to.

The biggest difference between runwhen and other schedulers is that runwhen doesn't have a single daemon overseeing multiple jobs. The runwhen tools essentially act as a glorified sleep command. Perhaps runwhen does nothing that at(1) doesn't, and there are lots of things at(1) does that runwhen doesn't: - runwhen doesn't change user IDs - thus it will never run anything as the wrong user. - It doesn't keep a central daemon running at all times - thus it won't break if that daemon dies. - It doesn't require any modifications to the system boot procedure. - It doesn't log through syslog(3) - thus it won't make a mess on the console if syslogd(1) isn't running. - It doesn't centralize storage of scheduled jobs (or any other per-job information) - thus unprivileged users can install and use it without cooperation from root, and without the use of a setuid program to handle changes. - It doesn't send output through mail - thus it doesn't break if there is no mail system installed. - It doesn't check access control files - thus it doesn't gratuitously deny users.

Many applications which process data-centric XML do that based on a nice specification, expressed in an XML Schema. XML::Compile reads and writes XML data with the help of such schema's. On the Perl side, it uses a tree of nested hashes with the same structure. Where other Perl modules, like SOAP::WSDL help you using these schema's (often with a lot of run-time (XPath) searches), this module takes a different approach: in stead of run-time processing of the specification, it will first compile the expected structure into real Perl, and then use that to process the data. There are many perl modules with the same as this one: translate between XML and nested hashes. However, there are a few serious differences: because the schema is used here, we make sure we only handle correct data. Data-types are formatted and processed correctly; for instance, integer does accept huge values (at least 18 digits) as the specification prescribes. Also more complex data-types like list, union, and substitutionGroup (unions on complex type level) are supported, which is rarely the case in other modules.

This program draws the Solar System's bodies in simulated 3-dimensionality. You can view all the planets, their moons and a few spaceships in motion, trace them, follow them, orbit them, and even control them. OpenUniverse was formerly known as Solar System Simulator (Ssystem). It was initially released in 1997 with the intent of creating a rotating display of the Earth on a mainstream PC. Ssystem version 1.0 was only aware of the planets. Version 1.2 added moons; and 1.6, more means of movement and better textures. The program has been renamed OpenUniverse 1.0 to underline the concept behind its further development: openness for the whole Universe, not just the solar system -- open for anyone to use, extend, and change.

Ardour is a digital audio workstation. You can use it to record, edit, and mix multi-track audio. Produce your own CD's. Mix video soundtracks. Experiment with new ideas about music and sound. Generate sound installations for 12 speaker gallery shows. Ardour capabilities include: multichannel recording, non-linear, non- destructive region based editing with unlimited undo/redo, full automation support, a mixer whose capabilities rival high end hardware consoles, lots of plugins to warp, shift, and shape your music, and controllable from hardware control surfaces at the same time as it syncs to timecode. If you have been looking for a tool similar to ProTools, Nuendo, Cubase SX, Digital Performer, Samplitude, or Sequoia, you might have found it.

Ezstream is a command line source client for Icecast media streaming servers. It began as the successor of the old "shout" utility, and has since gained a lot of useful features. In its basic mode of operation, it streams media files or data from standard input without reencoding and thus requires only very little CPU resources. It can also use various external decoders and encoders to reencode from one format to another, and stream the result to an Icecast server. Additional features include scriptable playlist and metadata handling. All of its features make ezstream a very flexible source client. Supported media formats for streaming are MP3, Ogg Vorbis and Ogg Theora. Native metadata support includes MP3 (ID3v1 only) and Ogg Vorbis, and many more formats when the optional TagLib support has been compiled in. Ezstream is free software and licensed under the GNU General Public License.

The other benchmark modules provide excellent timing for specific parts of your code. This module aims to allow you to easily time the progression of your code. The stopwatch analogy is that at some point you get a new stopwatch and start timing. Then you note certain events using lap. Finally you stop the watch and then print out a summary. The summary shows all the events in order, what time they occurred at, how long since the last lap and the percentage of the total time. Hopefully this will give you a good idea of where your code is spending most of its time. The times are all wallclock times in fractional seconds. That's it.