Python makes loading code dynamically easy, allowing you to configure
and extend your application by discovering and loading extensions
("plugins") at runtime. Many applications implement their own library
for doing this, using __import__ or importlib. Stevedore avoids
creating yet another extension mechanism by building on top of setuptools
entry points.
This is a backport of the standard library typing module to Python
versions older than 3.5.
Typing defines a standard notation for Python function and variable type
annotations. The notation can be used for documenting code in a concise,
standard format, and it has been designed to also be used by static and
runtime type checkers, static analyzers, IDEs and other tools.
A highly-available key value store for shared
configuration and service discovery. etcd is
inspired by zookeeper and doozer, with a focus on:
* Simple: curl'able user facing API (HTTP+JSON)
* Secure: optional SSL client cert authentication
* Fast: benchmarked 1000s of writes/s per instance
* Reliable: Properly distributed using Raft
Etcd is written in Go and uses the raft consensus
algorithm to manage a highly-available replicated log.
Validictory is a general purpose Python data validator.
It works with Python 2.7 and Python 3.3+ and uses a Schema format
based on JSON Schema Proposal (http://json-schema.org).
A highly-available key value store for shared
configuration and service discovery. etcd is
inspired by zookeeper and doozer, with a focus on:
* Simple: curl'able user facing API (HTTP+JSON)
* Secure: optional SSL client cert authentication
* Fast: benchmarked 1000s of writes/s per instance
* Reliable: Properly distributed using Raft
Etcd is written in Go and uses the raft consensus
algorithm to manage a highly-available replicated log.
PTypes is a C++ Portable Types Library. It offers the following features:
* Threads and synchronization objects along with message queues solve
the vital problem of diversity of the threading API's on different
platforms.
* IP socket classes and utilities provide complete IP-based framework
for both client-side and server-side programming. They can be
combined with PTypes multithreading.
* Dynamic strings, variants, character sets, date/time type and various
kinds of dynamic and associative arrays: Delphi programmers will find
them very similar to the ones in their favorite language.
* Streaming interfaces provide buffered I/O with simple and powerful text
parsing methods. A strictly defined syntax for the given text format
or a formal language can be represented by calls to PTypes token
extraction methods. The unified streaming interface is applicable to
files, named pipes and network sockets.
* Special thread class with enhanced functionality called unit. Units have
their own main() and input/output 'plugs'; they can be connected to each
other within one application to form pipes, like processes in the Unix shell.
* Finally, everything above is portable: all platform-dependent details
are hidden inside.
PhysicsFS is a library to provide abstract access to various archives.
It is intended for use in video games, and the design was somewhat
inspired by Quake 3's file subsystem. The programmer defines a "write
directory" on the physical filesystem. No file writing done through the
PhysicsFS API can leave that write directory, for security. For example,
an embedded scripting language cannot write outside of this path if it
uses PhysFS for all of its I/O, which means that untrusted scripts can
run more safely. Symbolic links can be disabled as well, for added
safety. For file reading, the programmer lists directories and archives
that form a "search path". Once the search path is defined, it becomes
a single, transparent hierarchical filesystem. This makes for easy
access to ZIP files in the same way as you access a file directly on the
disk, and it makes it easy to ship a new archive that will override a
previous archive on a per-file basis. Finally, PhysicsFS gives you
platform-abstracted means to determine if CD-ROMs are available, the
user's home directory, where in the real filesystem your program is
running, etc.
PhysicsFS is a library to provide abstract access to various archives.
It is intended for use in video games, and the design was somewhat
inspired by Quake 3's file subsystem. The programmer defines a "write
directory" on the physical filesystem. No file writing done through the
PhysicsFS API can leave that write directory, for security. For example,
an embedded scripting language cannot write outside of this path if it
uses PhysFS for all of its I/O, which means that untrusted scripts can
run more safely. Symbolic links can be disabled as well, for added
safety. For file reading, the programmer lists directories and archives
that form a "search path". Once the search path is defined, it becomes
a single, transparent hierarchical filesystem. This makes for easy
access to ZIP files in the same way as you access a file directly on the
disk, and it makes it easy to ship a new archive that will override a
previous archive on a per-file basis. Finally, PhysicsFS gives you
platform-abstracted means to determine if CD-ROMs are available, the
user's home directory, where in the real filesystem your program is
running, etc.
This is Picprog, pic16c84 programmer software for the serial port device.
To program a pic16c84 chip:
picprog --burn --input something.hex --pic /dev/cuaa1
Remember: this is not a production quality programmer! See PIC16C84
data sheet for more information.
Pinba is a statistics server for PHP using MySQL as a read-only
interface.
It accumulates and processes data sent over UDP by multiple PHP
processes and displays statistics in a nice human-readable form of
simple "reports", also providing a read-only interface to the raw
data to enable generation of more sophisticated reports.
With the Pinba extension, users can also measure particular parts
of the code using timers with arbitrary tags.
Pinba is not a debugging tool in the common sense, since you're not
supposed to do debugging on production servers, but its main goal
is to help developers to locate bottlenecks in realtime and direct
their attention to the code that really needs it.