• Daemon process that checks for login authentication failures for:
  • Courier imap, Dovecot, uw-imap, Kerio
  • openSSH
  • Pure-ftpd, vsftpd, Proftpd
  • Password protected web pages (htpasswd)
  • Mod_security failures (v1 and v2)
  • Suhosin failures
  • Exim SMTP AUTH
  • Custom login failures with separate log file and regular expression matching
• POP3/IMAP login tracking to enforce logins per hour
• SSH login notification
• SU login notification
• Excessive connection blocking
• Easy upgrade between versions from shell
• Auto-configures the SSH port if it\'s non-standard on installation
• Block traffic on unused server IP addresses - helps reduce the risk to your server
• Alert when end-user scripts sending excessive emails per hour - for identifying spamming scripts
• Suspicious process reporting - reports potential exploits running on the server
• Excessive user processes reporting
• Excessive user process usage reporting and optional termination
• Suspicious file reporting - reports potential exploit files in /tmp and similar directories
• Directory and file watching - reports if a watched directory or a file changes
• Block traffic on the DShield Block List and the Spamhaus DROP List
• BOGON packet protection
• Works with multiple ethernet devices
• Allow Dynamic DNS IP addresses - always allow your IP address even if it changes whenever you connect to the internet
• Alert sent if server load average remains high for a specified length of time
• mod_security log reporting (if installed)
• IDS (Intrusion Detection System) - the last line of detection alerts you to changes to system and application binaries
• SYN Flood protection
• Ping of death protection
• Port Scan tracking and blocking
• Permanent and Temporary (with TTL) IP blocking
• Exploit checks
• Account modification tracking - sends alerts if an account entry is modified, e.g. if the password is changed or the login shell
• Shared syslog aware
• Messenger Service - Allows you to redirect connection requests from blocked IP addresses to preconfigured text and html pages to inform the visitor that they have been blocked in the firewall. This can be particularly useful for those with a large user base and help process support requests more efficiently
• Country Code blocking - Allows you to deny or allow access by ISO Country Code
• Port Flooding Detection - Per IP, per Port connection flooding detection and mitigation to help block DOS attacks
• lfd Clustering - allows IP address blocks to be automatically propagated around a group of servers running lfd. It allows allows cluster-wide allows, removals and configuration changes
• Quick start csf - deferred startup by lfd for servers with large block and/or allow lists
• Distributed Login Failure Attack detection
• Temporary IP allows (with TTL)
• IPv6 Support with ip6tables
• System Statistics - Basic graphs showing the performance of the server, e.g. Load Averages, CPU Usage, Memory Usage, etc
• ...lots more!

APC Functions

• apc_add — Cache a new variable in the data store.
• apc_bin_dump — Get a binary dump of the given files and user variables
• apc_bin_dumpfile — Output a binary dump of cached files and user variables to a file
• apc_bin_load — Load a binary dump into the APC file/user cache
• apc_bin_loadfile — Load a binary dump from a file into the APC file/user cache
• apc_cache_info — Retrieves cached information from APC\'s data store
• apc_cas — Updates an old value with a new value
• apc_clear_cache — Clears the APC cache
• apc_compile_file — Stores a file in the bytecode cache, bypassing all filters.
• apc_dec — Decrease a stored number
• apc_define_constants — Defines a set of constants for retrieval and mass-definition
• apc_delete_file — Deletes files from the opcode cache
• apc_delete — Removes a stored variable from the cache
• apc_exists — Checks if APC key exists
• apc_fetch — Fetch a stored variable from the cache
• apc_inc — Increase a stored number
• apc_load_constants — Loads a set of constants from the cache
• aapc_sma_info — Retrieves APC\'s Shared Memory Allocation information
• apc_store — Cache a variable in the data store

• Personalize web content
• Tailor advertising
• Conduct traffic analysis
• Enforce digital rights
• Efficiently route Internet traffic
• Comply with legal regulations
• Detect online fraud through the minFraud service

• Optimized opcode cache.
• Using a generator to produce C code, reduces human mistake greatly.
• Running stable on PHP_4_3/PHP_4_4/PHP_5_1/PHP_5_2
• Supported and tested on all lastest php cvs branches, such as PHP_4_3 PHP_4_4 PHP_5_0 PHP_5_1 PHP_5_2 HEAD (6.x)
• Alpha supported for in-alpha-php6, with unicode enabled.
• Readonly Cacher Protection that prevents the cache from being corrupted by php-core/extension or any code other than XCache itself.
• Atomic get/set/inc/dec api operation on var cache for php programmers.
• XCache Uptime statistics collector (enabled by server admin), shows you how stable each XCache version is on each php version.
• Self sanity test at build time, discover C struct changes within the php script engine. catch up with new php version easier. see a real life example
• Automatically disables itself if the cache is corrupted
• Optimizer
• Disassembler. See how your php script is compiled into opcode.
• Decompiler. decompile opcode into php code.
• Coverager + real life testcase framework,
• real life testcase framework, a control script with real browser. you have to write the test cases.
• builtin Coverager + its viewer from web, to see how much script you have tested.

• ssh2_auth_agent — Authenticate over SSH using the ssh agent
• ssh2_auth_hostbased_file — Authenticate using a public hostkey
• ssh2_auth_none — Authenticate as none
• ssh2_auth_password — Authenticate over SSH using a plain password
• ssh2_auth_pubkey_file — Authenticate using a public key
• ssh2_connect — Connect to an SSH server
• ssh2_exec — Execute a command on a remote server
• ssh2_fetch_stream — Fetch an extended data stream
• ssh2_fingerprint — Retrieve fingerprint of remote server
• ssh2_methods_negotiated — Return list of negotiated methods
• ssh2_publickey_add — Add an authorized publickey
• ssh2_publickey_init — Initialize Publickey subsystem
• ssh2_publickey_list — List currently authorized publickeys
• ssh2_publickey_remove — Remove an authorized publickey
• ssh2_scp_recv — Request a file via SCP
• ssh2_scp_send — Send a file via SCP
• ssh2_sftp_chmod — Changes file mode
• ssh2_sftp_lstat — Stat a symbolic link
• ssh2_sftp_mkdir — Create a directory
• ssh2_sftp_readlink — Return the target of a symbolic link
• ssh2_sftp_realpath — Resolve the realpath of a provided path string
• ssh2_sftp_rename — Rename a remote file
• ssh2_sftp_rmdir — Remove a directory
• ssh2_sftp_stat — Stat a file on a remote filesystem
• ssh2_sftp_symlink — Create a symlink
• ssh2_sftp_unlink — Delete a file
• ssh2_sftp — Initialize SFTP subsystem
• ssh2_shell — Request an interactive shell
• ssh2_tunnel — Open a tunnel through a remote server

• intuitive, using a graph model for data representation
• reliable, with full ACID transactions
• durable and fast, using a custom disk-based, native storage engine
• massively scalable, up to several billion nodes/relationships/properties
• highly-available, when distributed across multiple machines
• expressive, with a powerful, human readable graph query language
• fast, with a powerful traversal framework for high-speed graph queries
• embeddable, with a few small jars
• simple, accessible by a convenient REST interface or an object-oriented JavaAPI

You can run atomic operations on these types, like appending to a string; incrementing the value in a hash; pushing to a list; computing set intersection, union and difference; or getting the member with highest ranking in a sorted set.

In order to achieve its outstanding performance, Redis works with an in-memory dataset. Depending on your use case, you can persist it either by dumping the dataset to disk every once in a while, or by appending each command to a log.

Redis also supports trivial-to-setup master-slave replication, with very fast non-blocking first synchronization, auto-reconnection on net split and so forth.

Other features include Transactions, Pub/Sub, Lua scripting, Keys with a limited time-to-live, and configuration settings to make Redis behave like a cache.

You can use Redis from most programming languages out there.

Redis is written in ANSI C and works in most POSIX systems like Linux, *BSD, OS X without external dependencies. Linux and OSX are the two operating systems where Redis is developed and more tested, and we recommend using Linux for deploying. Redis may work in Solaris-derived systems like SmartOS, but the support is best effort

Source for npm package meanio. mean-cli is a core package of the mean.io project and is used primarily to manage packages for extending functionality, for example adding a package to enable inline editable tokens. The cli provides a lot of useful functionality, such as scaffolding options to ceate new packages, assign roles to users, check the mongo status, add/remove packages and list currently installed packages.

• Linear and modular scalability.
• Strictly consistent reads and writes.
• Automatic and configurable sharding of tables
• Automatic failover support between RegionServers.
• Convenient base classes for backing Hadoop MapReduce jobs with Apache HBase tables.
• Easy to use Java API for client access.
• Block cache and Bloom Filters for real-time queries.
• Query predicate push down via server side Filters
• Thrift gateway and a REST-ful Web service that supports XML, Protobuf, and binary data encoding options
• Extensible jruby-based (JIRB) shell
• Support for exporting metrics via the Hadoop metrics subsystem to files or Ganglia; or via JMX

Design

One of the main features of Varnish is its design. Varnish is a modern program, designed and written for modern operating systems. To read more about the thoughts that lie behind the design see the architect notes.

VCL

Another main feature of Varnish is its configuration language. VCL is a domain specific language. Varnish compiles the configuration into binary code and runs it. VCL can be loaded and replaced on the fly.

All this adds a lot of speed and flexibility. To read more about the VCL start out with the main VCL page and the VCL examples.

A sub-feature of VCL - inline C

Varnish allows you to add C code in your VCL - giving you the option to easily expand Varnish on the fly.

Load balancing and backend health polling

As it\'s quite common to use more than one origin server to feed varnish, it has a built in load balancer. This consists of two parts:

• The health polling system, which maintains a list of backends able to receive traffic.
• The director, which directs the request to the right backend.

Edge Side Includes - ESI

ESI allows you to split up your web page into components cache them individually. If you\'re going to use Varnish to accelerate a dynamic web site with a lot of personalized content ESI is the key to success, more or less.

Graceful handling of dead and slow backends

Varnish can serve old content while the origin server generates new content. Work is underway to ensure that Varnish can also keep serving content if the origin server is crashed.

The web management administration interface

If you\'re managing a whole cluster of varnish servers you might find the Varnish Administration Console useful. It is only available for customers with a Varnish Enterprise Subscription.

The management port

A running Varnish cache can be managed with a management port. You can just telnet in and upload a new configuration, change settings, etc. .

Rewriting and redirecting URLs

Varnish can both rewrite and redirect URLs without any external programs.

Live statistics and logging

For performance reasons varnish logs to a shared memory segment. Several tools can be used to inspect and analyze the logs.

Varnishlog gives you a dump of the raw logs Varnishlog for an explanation of what the tags means.

varnishhist will give you a rather intuitive histogram of what the typical response times are.

varnishstat will give you a lot of statistics.

Memcached is a caching daemon designed especially for dynamic web applications to decrease database load by storing objects in memory. This extension allows you to work with memcached through handy OO and procedural interfaces.

Object-relational mapper

Define your data models entirely in Python. You get a rich, dynamic database-access API for free -; but you can still write SQL if needed.

Automatic admin interface

Save yourself the tedious work of creating interfaces for people to add and update content. Django does that automatically, and it\'s production-ready.

Elegant URL design

Design pretty, cruft-free URLs with no framework-specific limitations. Be as flexible as you like.

Template system

Use Django\'s powerful, extensible and designer-friendly template language to separate design, content and Python code.

Cache system

Hook into memcached or other cache frameworks for super performance -; caching is as granular as you need.

Internationalization

Django has full support for multi-language applications, letting you specify translation strings and providing hooks for language-specific functionality.

• Serving static and index files, autoindexing; open file descriptor cache;
• Accelerated reverse proxying with caching; simple load balancing and fault tolerance;
• Accelerated support with caching of FastCGI, uwsgi, SCGI, and memcached servers; simple load balancing and fault tolerance;
• Modular architecture. Filters include gzipping, byte ranges, chunked responses, XSLT, SSI, and image transformation filter. Multiple SSI inclusions within a single page can be processed in parallel if they are handled by proxied or FastCGI servers;
• SSL and TLS SNI support.

• Batch and Real-Time full-text indexes. Two index backends that support both efficient offline index construction andincremental on-the-fly index updates are available.
• Non-text attributes support. An arbitrary number of attributes (product IDs, company names, prices, etc) can be stored in the index and used either just for retrieveal (to avoid hitting the DB), or for efficient Sphinx-side search result set post-processing.
• SQL database indexing. Sphinx can directly access and index data stored in MySQL (all storage engines are supported), PostgreSQL, Oracle, Microsoft SQL Server, SQLite, Drizzle, and anything else that supports ODBC.
• Non-SQL storage indexing. Data can also be streamed to batch indexer in a simple XML format called XMLpipe, or inserted directly into an incremental RT index.
• Easy application integration. Sphinx comes with three different APIs, SphinxAPI, SphinxSE, and SphinxQL. SphinxAPI is a native library available for Java, PHP, Python, Perl, C, and other languages. SphinxSE, a pluggable storage engine for MySQL, enables huge result sets to be shipped directly to MySQL server for post-processing. SphinxQL lets the application query Sphinx using standard MySQL client libary and query syntax.
• Advanced full-text searching syntax. Our querying engine supports arbitrarily complex queries combining boolean operators, phrase, proximity, strict order, and quorum matching, field and position limits, exact keyword form matching, substring searches, etc.
• Rich database-like querying features. Sphinx does not limit you to just keyword searching. On top of full-text search result set, you can compute arbitrary arithmetic expressions, add WHERE conditions, do ORDER BY, GROUP BY, use MIN/MAX/AVG/SUM, aggregates etc. Essentially, full-blown SQL SELECT is supported.
• Better relevance ranking. Unlike many other engines, Sphinx does not solely rely on 30-year-old statistical ranking that only considers keyword frequencies, nor limits you to it. By default, Sphinx additionally analyzes keyword proximity, and ranks closer phrase matches higher, with perfect matches ranked on top. Also, ranking is flexible: you can choose from a number of built-in relevance functions, tweak their weights by using expressions, or develop new ones.
• Flexible text processing. Sphinx indexing features include full support for SBCS and UTF-8 encodings (meaning that effectively all world\'s languages are supported); stopword removal and optional hit position removal (hitless indexing); morphology and synonym processing through word forms dictionaries and stemmers; exceptions and blended characters; and many more.
• Distributed searching. Searches can be distributed across multiple machines, enabling horizontal scale-out and HA (High Availability).

Apache supports a variety of features, many implemented as compiled modules which extend the core functionality. These can range from server-side programming language support to authentication schemes. Some common language interfaces support Perl, Python, Tcl, and PHP. Popular authentication modules include mod_access, mod_auth, mod_digest, and mod_auth_digest, the successor to mod_digest. A sample of other features include Secure Sockets Layer and Transport Layer Security support (mod_ssl), a proxy module (mod_proxy), a URL rewriter (mod_rewrite), custom log files (mod_log_config), and filtering support (mod_include and mod_ext_filter).

Popular compression methods on Apache include the external extension module, mod_gzip, implemented to help with reduction of the size (weight) of web pages served over HTTP. ModSecurity is an open source intrusion detection and prevention engine for web applications. Apache logs can be analyzed through a web browser using free scripts such as AWStats/W3Perl or Visitors.

Virtual hosting allows one Apache installation to serve many different actual websites. For example, one machine with one Apache installation could simultaneously serve www.example.com, www.example.org, test47.test-server.example.edu, etc.

Apache features configurable error messages, DBMS-based authentication databases, and content negotiation. It is also supported by several graphical user interfaces (GUIs).

It supports password authentication and digital certificate authentication. Apache has a built in search engine and an HTML authorizing tool and supports FTP.

Because the source code is freely available, anyone can adapt the server for specific needs, and there is a large public library of Apache add-ons.

The open source software movement has received enormous attention in the last several years. It is often characterized as a fundamentally new way to develop software that poses a serious challenge to the commercial software businesses that dominate most software markets today.

• Supports programming with inheritance, mixins and metaclasses.
• Dynamic typing and duck typing.
• Literal notation for arrays and structs.
• Embedding variables in strings.
• Named arguments, optional arguments, and default arguments.
• Three levels of object variable scope: This (object public), Variables (object private), Local (function private).
• Multiple global variable scope: Request, Session, Client, Application, Server, Cluster.
• Distinct user-provided variable scopes: Form (post), Url (get), Cookie, CGI.
• Automatic garbage collection, (via JVM).
• Global and local exception handling, (via onError and try/catch.)
• Custom dispatch behaviour (through onMissingMethod and implicit getters and setters).
• Implicit object conversion (through _toString, _toNumeric, _toBoolean, _toDate).
• Native threads.
• Support for, multiple character encodings, and i18n.
• Large standard library, covering common web development needs.
• Native handling for easily creating and consuming web services.
• Separate GUI Administrators for individual web contexts, plus a global server administrator.
• All admin settings configurable programmatically, or via editing XML config files.
• Native resources for all built-in filesystem tags and functions.
• Clustering and Synchronization for both traditional and cloud servers.
• Task Manager for scheduling repeated actions, or re-trying failed events.
• Native support for Hibernate ORM.
• Large number of image manipulation functions.
• Event Gateways for asynchronous code execution.
• Native session management (CFML sessions or J2EE sessions) with onSessionStart and onSessionEnd triggers.
• Built-in user authentication and roles functionality.

• REST API for easy access from curl and any programming language
• Backup messages from a queue
• Replay by timestamp as needed
• Watch incoming messages with curl
• Alerts and monitoring

The same source code compiles and runs on Linux, OpenBSD, NetBSD, DragonflyBSD FreeBSD, Solaris, Tru64, Darwin, Irix, HPUX, AIX and iPhone. Pre-built binary packages are available for Novell, Mandriva, Debian, Ubuntu, PLD Linux, Stampede Linux, Slackware Linux (Slimslack), Multilinux, Sorcerer Linux, Fli4L (the one-disk router), ROOT Linux, Gentoo Linux and almost every other free operating system.

All server messages are translated in English, German, Romanian, French, Polish, Spanish, Danish, Dutch, Italian, Brazilian Portuguese, Slovak, Korean, Swedish, Norwegian, Russian, Traditional Chinese, Simplified Chinese, Czech, Turkish, Hungarian and Catalan. It helps your customers understand diagnostics, even when english isn\'t their native language. Messages are in independant files and they can be easily translated to new languages, or customized.

MariaDB strives to be the logical choice for database professionals looking for a robust, scalable, and reliable SQL server. To accomplish this, Monty Program works to hire the best and brightest developers in the industry, work closely and cooperatively with the larger community of users and developers in the true spirit of Free and open source software, and release software in a manner that balances predictability with reliability.

• Document-Oriented Storage :

  JSON-style documents with dynamic schemas offer simplicity and power.

• Full Index Support :

  Index on any attribute, just like you\'re used to.

• Replication & High Availability :

  Mirror across LANs and WANs for scale and peace of mind.

• Auto-Sharding :

  Scale horizontally without compromising functionality.

• Querying :

  Rich, document-based queries.

• Fast In-Place Updates :

  Atomic modifiers for contention-free performance.

• Map/Reduce :

  Flexible aggregation and data processing.

• GridFS :

  Store files of any size without complicating your stack.

• Commercial Support :

  Enterprise class support, training, and consulting available.

Featureful and Standards Compliant

PostgreSQL prides itself in standards compliance. Its SQL implementation strongly conforms to the ANSI-SQL:2008 standard. It has full support for subqueries (including subselects in the FROM clause), read-committed and serializable transaction isolation levels. And while PostgreSQL has a fully relational system catalog which itself supports multiple schemas per database, its catalog is also accessible through the Information Schema as defined in the SQL standard.

Data integrity features include (compound) primary keys, foreign keys with restricting and cascading updates/deletes, check constraints, unique constraints, and not null constraints.

It also has a host of extensions and advanced features. Among the conveniences are auto-increment columns through sequences, and LIMIT/OFFSET allowing the return of partial result sets. PostgreSQL supports compound, unique, partial, and functional indexes which can use any of its B-tree, R-tree, hash, or GiST storage methods.

GiST (Generalized Search Tree) indexing is an advanced system which brings together a wide array of different sorting and searching algorithms including B-tree, B+-tree, R-tree, partial sum trees, ranked B+-trees and many others. It also provides an interface which allows both the creation of custom data types as well as extensible query methods with which to search them. Thus, GiST offers the flexibility to specify what you store, how you store it, and the ability to define new ways to search through it --- ways that far exceed those offered by standard B-tree, R-tree and other generalized search algorithms.

GiST serves as a foundation for many public projects that use PostgreSQL such as OpenFTS and PostGIS. OpenFTS (Open Source Full Text Search engine) provides online indexing of data and relevance ranking for database searching. PostGIS is a project which adds support for geographic objects in PostgreSQL, allowing it to be used as a spatial database for geographic information systems (GIS), much like ESRI\'s SDE or Oracle\'s Spatial extension.

• Queries will run faster and more consistently
• You can consolidate servers on powerful hardware
• Sharding is delayed or avoided entirely
• You can save money on hosting fees and power
• You can spend less time tuning and administering
• You can achieve higher uptime
• Troubleshooting does not require guesswork

Scalability

Hypertable was designed for the express purpose of solving the scalability problem, a problem that is not handled well by a traditional RDBMS. While it is possible to design a distributed RDBMS system by breaking the dataset into shards, this solution requires an enormous amount of engineering effort and the resulting system will have inherent weaknesses because the core database engine was not designed for scalability. Hypertable is based on a design developed by Google to meet their scalability requirements and solves the scale problem better than any of the other NoSQL solutions out there.

Good Fit For Wide Range of Applications

Many of the current scalable NoSQL database offerings are based on a hash table design which means that the data they manage is not kept physically ordered by any meaningful key. These systems do not lend themselves well to applications that require fast access to ranges of data (e.g. analytics, sorted URL lists, messaging applications, etc). Because Hypertable keeps data physically sorted by a primary key, it is well-suited to a broad set of applications.

Cost Savings

Hypertable has been designed and implemented for maximum efficiency and optimum performance. By choosing to do the implementation in a compiled language that does not incur the performance and stability costs of garbage collection and runtime interpretation, Hypertable can deliver equivalent database capacity on a fraction of the hardware. This translates into less equipment, less power consumption, and less datacenter real estate.

Performance

The other benefit of Hypertable\'s highly efficient design and implementation is that it delivers all the advantages you get from better performance. For live applications, Hypertable can help deliver a much more responsive user experience by reducing overall request latency. For offline applications, higher throughput is achieved which means more work can be accomplished in a given amount of time.

Clean Semantics

Hypertable is a consistent database. Many of the scalable NoSQL database offerings are designed around the concept of eventual consistency which makes those databases more difficult to reason about. Eventually consistent databases require complex syntactic or semantic reconcilers and in some circumstances can even lose data. When an application writes data into Hypertable and gets a success response, the modification is durable and will always be reflected in subsequent operations.

Apache supports a variety of features, many implemented as compiled modules which extend the core functionality. These can range from server-side programming language support to authentication schemes. Some common language interfaces support Perl, Python, Tcl, and PHP. Popular authentication modules include mod_access, mod_auth, mod_digest, and mod_auth_digest, the successor to mod_digest. A sample of other features include Secure Sockets Layer and Transport Layer Security support (mod_ssl), a proxy module (mod_proxy), a URL rewriter (mod_rewrite), custom log files (mod_log_config), and filtering support (mod_include and mod_ext_filter).

Popular compression methods on Apache include the external extension module, mod_gzip, implemented to help with reduction of the size (weight) of web pages served over HTTP. ModSecurity is an open source intrusion detection and prevention engine for web applications. Apache logs can be analyzed through a web browser using free scripts such as AWStats/W3Perl or Visitors.

Virtual hosting allows one Apache installation to serve many different actual websites. For example, one machine with one Apache installation could simultaneously serve www.example.com, www.example.org, test47.test-server.example.edu, etc.

Apache features configurable error messages, DBMS-based authentication databases, and content negotiation. It is also supported by several graphical user interfaces (GUIs).

It supports password authentication and digital certificate authentication. Apache has a built in search engine and an HTML authorizing tool and supports FTP.

Because the source code is freely available, anyone can adapt the server for specific needs, and there is a large public library of Apache add-ons.

The open source software movement has received enormous attention in the last several years. It is often characterized as a fundamentally new way to develop software that poses a serious challenge to the commercial software businesses that dominate most software markets today.

Some of the most notable features of Dovecot include:

• Dovecot is among the highest performing IMAP servers while still supporting the standard mbox and Maildir formats. The mailboxes are transparently indexed, which gives Dovecot its good performance while still providing full compatibility with existing mailbox handling tools.
• Dovecot is standards compliant. Dovecot v1.1 passes all IMAP server standard compliancy tests while most other servers fail many of them.
• Dovecot\'s indexes are self-optimizing. They contain exactly what the user\'s client commonly needs, no more and no less.
• Dovecot is self-healing. It tries to fix most of the problems it notices by itself, such as broken index files. The problems are however logged so the administrator can later try to figure out what caused them.
• Dovecot tries to be admin-friendly. Common error messages are made as easily understandable as possible. Any crash, no matter how it happened, is considered a bug that will be fixed.
• Dovecot allows mailboxes and their indexes to be modified by multiple computers at the same time, while still performing well. This means that Dovecot works well with clustered filesystems. NFS has caching problems, but you can work around them with director proxies.
• Dovecot\'s user authentication is extremely flexible and feature-rich, supporting many different authentication databases and mechanisms.
• Postfix 2.3+ and Exim 4.64+ users can do SMTP authentication directly against Dovecot\'s authentication backend without having to configure it separately.
• Dovecot supports easy migration from many existing IMAP and POP3 servers, allowing the change to be transparent to existing users.
• Dovecot supports workarounds for several bugs in IMAP and POP3 clients. Since the workarounds may cause the protocol exchange to be slightly less optimal, you can enable only the workarounds you need.
• Dovecot\'s design and implementation is highly focused on security. Rather than taking the traditional road of just fixing vulnerabilities whenever someone happens to report them, I offer 1000 EUR of my own money to the first person to find a security hole from Dovecot.
• Dovecot is easily extensible. Plugins can add new commands, modify existing behavior, add their own data into index files or even add support for new mailbox formats. For example quota and ACL support are completely implemented as plugins.

• In addition to the benefits of parsing logs in a single stream, BFD also uses a log tracking system so logs are only parsed from the point which they were last read. This greatly assists in extending the performance of BFD even further as we are not constantly reading the same log data. The log tracking system is compatible with syslog/logrotate style log rotations which allows it to detect when rotations have happened and grab log tails from both the new log file and the rotated log file.

• You can also leverage BFD to block attackers using any number of tools such as APF, Shorewall, raw iptables, ip route or execute any custom command. There is also a fully customizable e-mail alerting system with an e-mail template that is well suited for every day use or you can open it up and modify it.

• The attacker tracking in BFD is handled using simple flat text files that are size-controlled to prevent space constraints over time, ideal for disk less devices. There is also an attack pool where trending data is stored on all hosts hat have been blocked including which rule the block was triggered by.

• In the execution process, there is simply a cron job that executes BFD once every 3 minutes by default. An embedded lock file system makes sure that no two instances ever run at the same time, preventing messy and potentially load heavy results. The cronjob can be run more frequently for those that desire it and doing so will not cause any performance issues (no less than once a minute).

• Load balancing FastCGI, SCGI and HTTP proxy support
• chroot support
• select()-/poll()-/epoll() based web server
• Support for more efficient event notification schemes like kqueue and epoll
• Conditional rewrites (mod_rewrite)
• TLS/SSL with SNI support, via OpenSSL.
• Authentication against an LDAP server
• RRDtool statistics
• Rule-based downloading with possibility of a script handling only authentication
• Server Side Includes support (but not server-side CGI)[7]
• Flexible virtual hosting
• Modules support
• Cache Meta Language (currently being replaced by mod_magnet) using the Lua programming language
• Minimal WebDAV support
• Servlet (AJP) support (in versions 1.5.x and up)
• HTTP compression using mod_compress and the newer mod_deflate (1.5.x)
• Light-weight (less than 1 MB)
• Single-process design with only several threads. No processes or threads started per connection.

Node\'s goal is to provide an easy way to build scalable network programs

Node.js contains a built-in HTTP server library, making it possible to run a web server without the use of external software, such as Apache or Lighttpd, and allowing more control of how the web server works. Node.js enables web developers to create an entire web application in JavaScript, both server-side and client-side.

• Frictionless Context Switching. Create a branch to try out an idea, commit a few times, switch back to where you branched from, apply a patch, switch back to where you are experimenting, and merge it in.
• Role-Based Codelines. Have a branch that always contains only what goes to production, another that you merge work into for testing, and several smaller ones for day to day work.
• Feature Based Workflow. Create new branches for each new feature you\'re working on so you can seamlessly switch back and forth between them, then delete each branch when that feature gets merged into your main line.
• Disposable Experimentation. Create a branch to experiment in, realize it\'s not going to work, and just delete it - abandoning the work—with nobody else ever seeing it (even if you\'ve pushed other branches in the meantime).

• Real Time Data.
• Real Time Analytics.
• Distributed.
• High Availability.
• Multi-tenancy.
• Full Text Search.
• Document Oriented.
• Conflict Management.
• Schema Free.
• RESTful API.
• Per-operation Persistence.
• Apache 2 Open Source License.
• Build on top of Apache Lucene ™.

1. Introduction - A brief, high level, overview of Apache Tomcat.
2. Setup - How to install and run Apache Tomcat on a variety of platforms.
3. First web application - An introduction to the concepts of a web application as defined in the Servlet Specification. Covers basic organization of your web application source tree, the structure of a web application archive, and an introduction to the web application deployment descriptor (/WEB-INF/web.xml).
4. Deployer - Operating the Apache Tomcat Deployer to deploy, precompile, and validate web applications.
5. Manager - Operating the Manager web app to deploy, undeploy, and redeploy applications while Apache Tomcat is running.
6. Realms and Access Control - Description of how to configure Realms (databases of users, passwords, and their associated roles) for use in web applications that utilize Container Managed Security.
7. Security Manager - Configuring and using a Java Security Manager to support fine-grained control over the behavior of your web applications.
8. JNDI Resources - Configuring standard and custom resources in the JNDI naming context that is provided to each web application.
9. JDBC DataSource - Configuring a JNDI DataSoure with a DB connection pool. Examples for many popular databases.
10. Classloading - Information about class loading in Apache Tomcat, including where to place your application classes so that they are visible.
11. JSPs - Information about Jasper configuration, as well as the JSP compiler usage.
12. SSL - Installing and configuring SSL support so that your Apache Tomcat will serve requests using the https protocol.
13. SSI - Using Server Side Includes in Apache Tomcat.
14. CGI - Using CGIs with Apache Tomcat.
15. Proxy Support - Configuring Apache Tomcat to run behind a proxy server (or a web server functioning as a proxy server).
16. MBean Descriptor - Configuring MBean descriptors files for custom components.
17. Default Servlet - Configuring the default servlet and customizing directory listings.
18. Apache Tomcat Clustering - Enable session replication in a Apache Tomcat environment.
19. Balancer - Configuring, using, and extending the load balancer application.
20. Connectors - Connectors available in Apache Tomcat, and native web server integration.
21. Monitoring and Management - Enabling JMX Remote support, and using tools to monitor and manage Apache Tomcat.
22. Logging - Configuring logging in Apache Tomcat.
23. Apache Portable Runtime - Using APR to provide superior performance, scalability and better integration with native server technologies.
24. Virtual Hosting - Configuring virtual hosting in Apache Tomcat.
25. Advanced IO - Extensions available over regular, blocking IO.
26. Additional Components - Obtaining additional, optional components.
27. Using Tomcat libraries with Maven - Obtaining Tomcat jars through Maven.
28. Security Considerations - Options to consider when securing an Apache Tomcat installation.
29. Windows Service - Running Tomcat as a service on Microsoft Windows.
30. Windows Authentication - Configuring Tomcat to use integrated Windows authentication.
31. High Concurrency JDBC Pool - Configuring Tomcat to use an alternative JDBC pool.
32. WebSocket support - Developing WebSocket applications for Apache Tomcat.

memcached allows you to take memory from parts of your system where you have more than you need and make it accessible to areas where you have less than you need.

memcached also allows you to make better use of your memory. If you consider the diagram to the right, you can see two deployment scenarios:

1. Each node is completely independent (top).
2. Each node can make use of memory from other nodes (bottom).

The first scenario illustrates the classic deployment strategy, however you\'ll find that it\'s both wasteful in the sense that the total cache size is a fraction of the actual capacity of your web farm, but also in the amount of effort required to keep the cache consistent across all of those nodes.

With memcached, you can see that all of the servers are looking into the same virtual pool of memory. This means that a given item is always stored and always retrieved from the same location in your entire web cluster.

Also, as the demand for your application grows to the point where you need to have more servers, it generally also grows in terms of the data that must be regularly accessed. A deployment strategy where these two aspects of your system scale together just makes sense.

The illustration to the right only shows two web servers for simplicity, but the property remains the same as the number increases. If you had fifty web servers, you\'d still have a usable cache size of 64MB in the first example, but in the second, you\'d have 3.2GB of usable cache.

Of course, you aren\'t required to use your web server\'s memory for cache. Many memcached users have dedicated machines that are built to only be memcached servers.

Rails is a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern.

Understanding the MVC pattern is key to understanding Rails. MVC divides your application into three layers, each with a specific responsibility.

The View layer is composed of "templates" that are responsible for providing appropriate representations of your application\'s resources. Templates can come in a variety of formats, but most view templates are HTML with embedded Ruby code (ERB files).

The Model layer represents your domain model (such as Account, Product, Person, Post, etc.) and encapsulates the business logic that is specific to your application. In Rails, database-backed model classes are derived from ActiveRecord::Base. Active Record allows you to present the data from database rows as objects and embellish these data objects with business logic methods. Although most Rails models are backed by a database, models can also be ordinary Ruby classes, or Ruby classes that implement a set of interfaces as provided by the Active Model module. You can read more about Active Record in its README.

The Controller layer is responsible for handling incoming HTTP requests and providing a suitable response. Usually this means returning HTML, but Rails controllers can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers manipulate models and render view templates in order to generate the appropriate HTTP response.

In Rails, the Controller and View layers are handled together by Action Pack. These two layers are bundled in a single package due to their heavy interdependence. This is unlike the relationship between Active Record and Action Pack, which are independent. Each of these packages can be used independently outside of Rails.

In Ruby, everything is an object. Every bit of information and code can be given their own properties and actions. Object-oriented programming calls properties by the name instance variables and actions are known as methods. Ruby\'s pure object-oriented approach is most commonly demonstrated by a bit of code which applies an action to a number.

Ruby is seen as a flexible language, since it allows its users to freely alter its parts. Essential parts of Ruby can be removed or redefined, at will. Existing parts can be added upon. Ruby tries not to restrict the coder.

• It is possible to compile a large Go program in a few seconds on a single computer.
• Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.
• Go\'s type system has no hierarchy, so no time is spent defining the relationships between types. Also, although Go has static types the language attempts to make types feel lighter weight than in typical OO languages.
• Go is fully garbage-collected and provides fundamental support for concurrent execution and communication.
• By its design, Go proposes an approach for the construction of system software on multicore machines.

• Most CVS features.

  CVS is a relatively basic version control system. For the most part, Subversion has matched or exceeded CVS\'s feature set where those features continue to apply in Subversion\'s particular design.

• Directories are versioned.

  Subversion versions directories as first-class objects, just like files.

• Copying, deleting, and renaming are versioned.

  Copying and deleting are versioned operations. Renaming is also a versioned operation, albeit with some quirks.

• Free-form versioned metadata ("properties").

  Subversion allows arbitrary metadata ("properties") to be attached to any file or directory. These properties are key/value pairs, and are versioned just like the objects they are attached to. Subversion also provides a way to attach arbitrary key/value properties to a revision (that is, to a committed changeset). These properties are not versioned, since they attach metadata to the version-space itself, but they can be changed at any time.

• Atomic commits.

  No part of a commit takes effect until the entire commit has succeeded. Revision numbers are per-commit, not per-file, and commit\'s log message is attached to its revision, not stored redundantly in all the files affected by that commit.

• Branching and tagging are cheap (constant time) operations.

  There is no reason for these operations to be expensive, so they aren\'t.

  Branches and tags are both implemented in terms of an underlying "copy" operation. A copy takes up a small, constant amount of space. Any copy is a tag; and if you start committing on a copy, then it\'s a branch as well. (This does away with CVS\'s "branch-point tagging", by removing the distinction that made branch-point tags necessary in the first place.)

• Merge tracking.

  Subversion 1.5 introduces merge tracking: automated assistance with managing the flow of changes between lines of development, and with the merging of branches back into their sources. The 1.5 release of merge tracking has basic support for common scenarios; we will be extending the feature in upcoming releases.

• File locking.

  Subversion supports (but does not require) locking files so that users can be warned when multiple people try to edit the same file. A file can be marked as requiring a lock before being edited, in which case Subversion will present the file in read-only mode until a lock is acquired.

• Symbolic links can be versioned.

  Unix users can place symbolic links under version control. The links are recreated in Unix working copies, but not in win32 working copies.

• Executable flag is preserved.

  Subversion notices when a file is executable, and if that file is placed into version control, its executability will be preserved when it it checked out to other locations. (The mechanism Subversion uses to remember this is simply versioned properties, so executability can be manually edited when necessary, even from a client that does not acknowledge the file\'s executability, e.g., when having the wrong extension under Microsoft Windows).

• Standalone server option (svnserve).

  Subversion offers a standalone server option using a custom protocol, since not everyone wants to run an Apache HTTPD server. The standalone server can run as an inetd service or in daemon mode, and offers the same level of authentication and authorization functionality as the HTTPD-based server. The standalone server can also be tunnelled over ssh.

1. Support for Java Servlet 3.1, JavaServer Pages 2.3, Java Unified Expression Language 3.0 and Java WebSocket 1.0.
2. The default connector implementation is now the Java non-blocking implementation (NIO) for both HTTP and AJP.
3. A new resources implementation that replaces Aliases, VirtualLoader, VirtualDirContext, JAR resources and external repositories with a single, consistent approach for configuring additional web application resources. The new resources implementation can also be used to implement overlays (using a master WAR as the basis for multiple web applications that each have their own customizations).

Multi-Model

OrientDB is an Open Source NoSQL DBMS with the features of both Document and Graph DBMSs. Written in Java, it is incredibly fast: it can store up to 150,000 records per second on common hardware. Even for a Document based database, the relationships are managed as in Graph Databases with direct connections among records. You can traverse parts of or entire trees and graphs of records in a few milliseconds. Supports schema-less, schema-full and schema-mixed modes. Has a strong security profiling system based on user and roles and supports SQL amongst the query languages. Thanks to the SQL layer, it’s straightforward to use for those skilled in the relational database world.

No More Joins

OrientDB can embed documents like any other Document Database, but can also connect documents like a Relational Database. The main difference is that OrientDB doesn’t use the costly JOIN, but rather uses direct, super-fast links taken from the Graph Database world. No duplicates: the resulting database is smaller and lighter Faster: a smaller database means better usage of RAM thus allowing more caching Upon loading the order document, OrientDB will assemble the entire document by fetching all the connections transparently.

Speed

OrientDB has been designed to be very fast. It inherits the best features and concepts from Document, Graph and Object Databases. Furthermore it uses the own MVRB-Tree algorithm as a mix of Red-Black Tree and B+Tree. MVRB-Tree consumes about half memory of the Red-Black Tree implementation maintaining the original speed while it balances the tree on insertion/update. Furthermore the MVRB-Tree allows fast retrieving and storing of nodes in persistent way.

Scalability

The most common reason applications scale up badly is, very often, the database. The database is the bottleneck of most applications. OrientDB scales up very well on a single machine. A single server does the work of about 125 servers running MySQL. The transactional engine can run in distributed systems supporting up to 302,231,454,903,657 billion (2^78) records for the maximum capacity of 19,807,040,628,566,084 Terabytes of data distributed on multiple disks in multiple nodes.

Zero Configuration Clustering

When you need more throughput, simply add a new server in the network and it will join the current distributed server cluster. Synchronization occurs automatically as soon as the server is brought online. You can’t get it much easier than that!

Reliability

What happens when a server node crashes? The server cluster redistributes the load across the available nodes and all the clients connected to the node in failure are automatically switched to an available server node with no fail-over to the application level.

Competitor DBMSs

OrientDB is a Document-Graph DBMS, so you can compare it against DocumentDB and GraphDB products. If you already know MongoDB, look at OrientDB vs MongoDB page. Also, take a look at GraphDB comparison and DocumentDB comparison. What about speed? Download the independent Benchmark between GraphDB products “XGDBench: A Benchmarking Platform for Graph Stores in Exascale Clouds“ by Tokyo Institute of Technology and IBM Research.

Easy to install and use?

Absolutely. OrientDB is written completely in Java and can run on any platform without configuration and installation. The Full Server distribution is about 1Mb without the demo database. Do you develop with a language different than Java? No problem, look at the Programming Language Bindings.

• Format conversion: convert an image from one format to another (e.g. PNG to JPEG).
• Transform: resize, rotate, crop, flip or trim an image.
• Transparency: render portions of an image invisible.
• Draw: add shapes or text to an image.
• Decorate: add a border or frame to an image.
• Special effects: blur, sharpen, threshold, or tint an image.
• Animation: create a GIF animation sequence from a group of images.
• Text and comments: insert descriptive or artistic text in an image.
• Image identification: describe the format and attributes of an image.
• Composite: overlap one image over another.
• Montage: juxtapose image thumbnails on an image canvas.
• Generalized pixel distortion: correct for, or induce image distortions including perspective.
• Morphology of shapes: extract features, describe shapes, and recognize patterns in images.
• Delineate image features: Canny edge detection, mean-shift, Hough lines.
• Motion picture support: read and write the common image formats used in digital film work.
• Image calculator: apply a mathematical expression to an image or image channels.
• Discrete Fourier transform: implements the forward and inverse DFT.
• Perceptual hash: map visually identical images to the same or similar hash-- useful in image retrieval, authentication, indexing, or copy detection as well as digital watermarking.
• Color management: accurate color management with color profiles or in lieu of-- built-in gamma compression or expansion as demanded by the colorspace.
• High dynamic-range images: accurately represent the wide range of intensity levels found in real scenes ranging from the brightest direct sunlight to the deepest darkest shadows.
• Encipher or decipher an image: convert ordinary images into unintelligible gibberish and back again.
• Virtual pixel support: convenient access to pixels outside the image region.
• Large image support: read, process, or write mega-, giga-, or tera-pixel image sizes.
• Threads of execution support: ImageMagick is thread safe and most internal algorithms execute in parallel to take advantage of speed-ups offered by multicore processor chips.
• Distributed pixel cache: offload intermediate pixel storage to one or more remote servers.
• Heterogeneous distributed processing: certain algorithms are OpenCL-enabled to take advantage of speed-ups offered by executing in concert across heterogeneous platforms consisting of CPUs, GPUs, and other processors.
• ImageMagick on the iPhone: convert, edit, or compose images on your iOS device such as the iPhone or iPad.

Ant is written in Java. Users of Ant can develop their own "antlibs" containing Ant tasks and types, and are offered a large number of ready-made commercial or open-source "antlibs".Ant is extremely flexible and does not impose coding conventions or directory layouts to the Java projects which adopt it as a build tool. Software development projects looking for a solution combining build tool and dependency management can use Ant in combination with Apache Ivy.

• very clear, readable syntax
• strong introspection capabilities
• intuitive object orientation
• natural expression of procedural code
• full modularity, supporting hierarchical packages
• exception-based error handling
• very high level dynamic data types
• extensive standard libraries and third party modules for virtually every task
• extensions and modules easily written in C, C++ (or Java for Jython, or .NET languages for IronPython)
• embeddable within applications as a scripting interface

• Flexible, Extensible, and Customizable
• Enhancing Developer Productivity
• Production Readiness
• Extending JavaEE with Clustering
• Load Balancing Support
• JMSand Message Queue Broker
• DAS Backupand Recovery
• Logging Service

• Simple project setup that follows best practices - get a new project or module started in seconds
• Consistent usage across all projects means no ramp up time for new developers coming onto a project
• Superior dependency management including automatic updating, dependency closures (also known as transitive dependencies)
• Able to easily work with multiple projects at the same time
• A large and growing repository of libraries and metadata to use out of the box, and arrangements in place with the largest Open Source projects for real-time availability of their latest releases
• Extensible, with the ability to easily write plugins in Java or scripting languages
• Instant access to new features with little or no extra configuration
• Ant tasks for dependency management and deployment outside of Maven
• Model based builds: Maven is able to build any number of projects into predefined output types such as a JAR, WAR, or distribution based on metadata about the project, without the need to do any scripting in most cases.
• Coherent site of project information: Using the same metadata as for the build process, Maven is able to generate a web site or PDF including any documentation you care to add, and adds to that standard reports about the state of development of the project. Examples of this information can be seen at the bottom of the left-hand navigation of this site under the "Project Information" and "Project Reports" submenus.
• Release management and distribution publication: Without much additional configuration, Maven will integrate with your source control system such as CVS and manage the release of a project based on a certain tag. It can also publish this to a distribution location for use by other projects. Maven is able to publish individual outputs such as a JAR, an archive including other dependencies and documentation, or as a source distribution.
• Dependency management: Maven encourages the use of a central repository of JARs and other dependencies. Maven comes with a mechanism that your project\'s clients can use to download any JARs required for building your project from a central JAR repository much like Perl\'s CPAN. This allows users of Maven to reuse JARs across projects and encourages communication between projects to ensure that backward compatibility issues are dealt with. We are collaborating with the folks at Ibiblio who have graciously allowed the central repository to live on their servers.

• Distributed architecture. Traditional version control systems such as Subversion are typical client-server architectures with a central server to store the revisions of a project. In contrast, Mercurial is truly distributed, giving each developer a local copy of the entire development history. This way it works independent of network access or a central server. Committing, branching and merging are fast and cheap..
• Platform independent. Mercurial was written with platform independence in mind. Therefore most of Mercurial is written in Python, with a small part in portable C for performance reasons. As a result, binary releases are available on all major platforms.
• Fast. Mercurials implementation and data structures are designed to be fast. You can generate diffs between revisions, or jump back in time within seconds. Therefore Mercurial is perfectly suitable for large projects such as OpenJDK (hg) or NetBeans (hg).
• Easy to use.Mercurial sports a consistent command set in which most subversion users feel right at home. Potentially dangerous actions are available via extensions you need to enable, so the basic interface is easy to use, easy to learn and hard to break. The Quick Start should get you going in a just few minutes.

The combined usage of all LES options provides an increased level of local environment security, with the goal of preventing environment based attacks. Such attacks would consist of compromised system binaries; tainting the $PATH variable to point to invalid paths where trojan/malicious binaries are located; alterations to user profile scripts to activate key loggers or process based hi-jacking; traversal exploration of the system paths etc…; the possible attack trends are numerious hence the importance of hardening the local environment space.

Proxy

• Artifactory acts as a proxy between your build tool (Maven, Ant, Ivy, Gradle etc.) and the outside world.

Local Cache

• It caches remote artifacts so that you don\'t have to download them over and over again.

Control

• It blocks unwanted (and sometimes security-sensitive) external requests for internal artifacts and controls how and where artifacts are deployed, and by whom.

Stability

• Built on top of the Java Content Repository (JCR), Artifactory supports extremely high concurrency and offers unmatched data integrity.

Diligent

• The underlying, backup-ready storage supports Artifactory\'s OpenMetadata(TM) technology, allowing every repository item to be attached with searchable XML metadata and user-defined properties.

Robust Architecture

• Built on top of the Java Content Repository (JCR), Artifactory offers higher concurrency and unmatched data integrity. When run on top of MySQL Artifactory can support an amazingly high volume of concurrent downloads and deployments.

• Robust messaging for applications
• Easy to use
• Runs on all major operating systems
• Supports a huge number of developer platforms
• Open source and commercially supported

Reliability

RabbitMQ offers a variety of features to let you trade off performance with reliability, including persistence, delivery acknowledgements, publisher confirms, and high availability.

Flexible Routing

Messages are routed through exchanges before arriving at queues. RabbitMQ features several built-in exchange types for typical routing logic. For more complex routing you can bind exchanges together or even write your own exchange type as a plugin.

Clustering

Several RabbitMQ servers on a local network can be clustered together, forming a single logical broker.

Federation

For servers that need to be more loosely and unreliably connected than clustering allows, RabbitMQ offers a federation model.

Highly Available Queues

Queues can be mirrored across several machines in a cluster, ensuring that even in the event of hardware failure your messages are safe.

Multi-protocol

RabbitMQ supports messaging over a variety of messaging protocols.

Many Clients

There are RabbitMQ clients for almost any language you can think of.

Management UI

RabbitMQ ships with an easy-to use management UI that allows you to monitor and control every aspect of your message broker.

Tracing

If your messaging system is misbehaving, RabbitMQ offers tracing support to let you find out what\'s going on.

Plugin System

RabbitMQ ships with a variety of plugins extending it in different ways, and you can also write your own.

• Write software on one platform and run it on virtually any other platform
• Create programs that can run within a web browser and access available web services
• Develop server-side applications for online forums, stores, polls, HTML forms processing, and more
• Combine applications or services using the Java language to create highly customized applications or services
• Write powerful and efficient applications for mobile phones, remote processors, consumer products, and practically any other electronic device

• Write software on one platform and run it on virtually any other platform
• Create programs that can run within a web browser and access available web services
• Develop server-side applications for online forums, stores, polls, HTML forms processing, and more
• Combine applications or services using the Java language to create highly customized applications or services
• Write powerful and efficient applications for mobile phones, remote processors, consumer products, and practically any other electronic device

• Full-featured and standards-based
• Open source and commercially usable
• Flexible and extensible
• Small footprint
• Embeddable
• Asynchronous
• Enterprise scalable
• Dual licensed under Apache and Eclipse

• It can run scripts which you can supply to log CVS operations or enforce site-specific polices.
• Client/server CVS enables developers scattered by geography or slow modems to function as a single team. The version history is stored on a single central server and the client machines have a copy of all the files that the developers are working on. Therefore, the network between the client and the server must be up to perform CVS operations (such as checkins or updates) but need not be up to edit or manipulate the current versions of the files. Clients can perform all the same operations which are available locally.
• In cases where several developers or teams want to each maintain their own version of the files, because of geography and/or policy, CVS\'s vendor branches can import a version from another team (even if they don\'t use CVS), and then CVS can merge the changes from the vendor branch with the latest files if that is what is desired.
• Unreserved checkouts, allowing more than one developer to work on the same files at the same time.
• CVS provides a flexible modules database that provides a symbolic mapping of names to components of a larger software distribution. It applies names to collections of directories and files. A single command can manipulate the entire collection.
• CVS servers run on most unix variants, and clients for Windows NT/95, OS/2 and VMS are also available. CVS will also operate in what is sometimes called server mode against local repositories on Windows 95/NT.

• Offline mode. You can commit changes even if you\'re on the road with no access to the server. That\'s because your own working directory is a repository in its own right. When you get home, you do a darcs push to commit to the public server.
• Easy branching and merging. Every repository is a branch. There is no branch administration except pushing and pulling between repositories.
• Easy patch sending by e-mail. I want to add a feature or bugfix to an open-source project. I make a local Darcs copy, apply my changes, then send my changes by email (darcs send). The project\'s maintainer(s) can decide whether to accept or reject the changes. This way, the maintainer(s) of the main repository do not need to give commit privileges to anyone else. This is how Darcs itself is maintained, by the way.
• Parallel development. Let\'s say I follow the development of this open-source project, and I have some controversial patches that aren\'t accepted by the official maintainers. No problem – I make my changes, release my own distribution. It\'s a fork, of sorts, but it\'s still connected to the mainline. Whenever the official project makes changes, I do a darcs pull to get them, and resolve any conflicts. This way, my fork is kept up to date with the main project\'s repository.
• Cherry-picking. If you\'ve ever worked on a team, you will know that somebody often has a change you want, but which can\'t be committed to the trunk yet. With Darcs you can grab just the one change by pulling it into your repository.
• Interactivity. When you record a patch, Darcs enables you to be precise and say "yes" or "no" to every change that you can include in your patch. Thus you can really create minimal patches, or separate your work in several patches, each one doing a consistent change. You can also tell Darcs to record everything in one patch by passing the -a flag to darcs record. Other commands, like darcs pull and darcs push, behave the same.

• Version control for everyone
• Work offline
• Any workflow
• Cross platform support
• Rename tracking and smart merging
• High storage efficiency and speed
• Any workspace model
• Plays well with others
• Launchpad
• Plugins and bzrlib

• An easy to use Object Relational Mapping (ORM) layer built on Hibernate
• An expressive view technology called Groovy Server Pages (GSP)
• A controller layer built on Spring MVC
• A command line scripting environment built on the Groovy-powered Gant
• An embedded Tomcat container which is configured for on the fly reloading
• Dependency injection with the inbuilt Spring container
• Support for internationalization (i18n) built on Spring\'s core MessageSource concept
• A transactional service layer built on Spring\'s transaction abstraction

ElasticMQ follows the semantics of SQS. Messages are received by polling the queue. When a message is received, it is blocked for a specified amount of time (the visibility timeout). If the message isn\'t deleted during that time, it will be again available for delivery. Moreover, queues and messages can be configured to always deliver messages with a delay.

The focus in SQS (and ElasticMQ) is to make sure that the messages are delivered. It may happen, however, that a message is delivered twice (if, for example, a client dies after receiving a message and processing it, but before deleting). That\'s why clients of ElasticMQ (and Amazon SQS) should be idempotent.

As ElasticMQ implements a subset of the SQS query (REST) interface, it is a great SQS alternative both for testing purposes (ElasticMQ is easily embeddable) and for creating systems which work both within and outside of the Amazon infrastructure.

• Designed for flexibility.
• Amped with electrifying speed.
• Launch your Java EE applications in a flash!

• Unparalleled Speed
• Modular Design
• Exceptionally Lightweight
• Elegant Administration
• Strict Compliance
• Easily Testable
• First class, modern components

Most people use Infinispan for one of two reasons. Firstly, as a distributed cache. Putting Infinispan in front of your database, disk-based NoSQL store or any part of your system that is a bottleneck can greatly help improve performance. Often, a simple cache isn\'t enough - for example if your application is clustered and cache coherency is important to data consistency. A distributed cache can greatly help here.

The other major use-case is as a NoSQL data store. In addition to being in memory, Infinispan can also persist data to a more permanent store. We call this a cache store. Cache stores are pluggable, you can easily write your own, and many already exist for you to use. Learn more about cache stores and existing implementations you can use today - on the cache stores section of this website.

A less common use case is adding clusterability and high availability to frameworks. Since Infinispan exposes a distributed data structure, frameworks and libraries that also need to be clustered can easily achieve this by embedding Infinispan and delegating all state management to Infinispan. This way, any framework can easily be clustered by letting Infinispan do all the heavy lifting.

• very clear, readable syntax
• strong introspection capabilities
• intuitive object orientation
• natural expression of procedural code
• full modularity, supporting hierarchical packages
• exception-based error handling
• very high level dynamic data types
• extensive standard libraries and third party modules for virtually every task
• extensions and modules easily written in C, C++ (or Java for Jython, or .NET languages for IronPython)
• embeddable within applications as a scripting interface

ZooKeeper is simple. ZooKeeper allows distributed processes to coordinate with each other through a shared hierarchal namespace which is organized similarly to a standard file system. The name space consists of data registers - called znodes, in ZooKeeper parlance - and these are similar to files and directories. Unlike a typical file system, which is designed for storage, ZooKeeper data is kept in-memory, which means ZooKeeper can achieve high throughput and low latency numbers.

The ZooKeeper implementation puts a premium on high performance, highly available, strictly ordered access. The performance aspects of ZooKeeper means it can be used in large, distributed systems. The reliability aspects keep it from being a single point of failure. The strict ordering means that sophisticated synchronization primitives can be implemented at the client.

ZooKeeper is replicated. Like the distributed processes it coordinates, ZooKeeper itself is intended to be replicated over a sets of hosts called an ensemble.

The servers that make up the ZooKeeper service must all know about each other. They maintain an in-memory image of state, along with a transaction logs and snapshots in a persistent store. As long as a majority of the servers are available, the ZooKeeper service will be available.

Clients connect to a single ZooKeeper server. The client maintains a TCP connection through which it sends requests, gets responses, gets watch events, and sends heart beats. If the TCP connection to the server breaks, the client will connect to a different server.

ZooKeeper is ordered. ZooKeeper stamps each update with a number that reflects the order of all ZooKeeper transactions. Subsequent operations can use the order to implement higher-level abstractions, such as synchronization primitives.

ZooKeeper is fast. It is especially fast in "read-dominant" workloads. ZooKeeper applications run on thousands of machines, and it performs best where reads are more common than writes, at ratios of around 10:1.

Schema

• Defines the field types and fields of documents
• Can drive more intelligent processing
• Declarative Lucene Analyzer specification
• Dynamic Fields enables on-the-fly addition of new fields

Query

• HTTP interface with configurable response formats (XML/XSLT, JSON, Python, Ruby, PHP, Velocity, CSV, binary)
• Sort by any number of fields, and by complex functions of numeric fields
• Advanced DisMax query parser for high relevancy results from user-entered queries
• Highlighted context snippets
• Faceted Searching based on unique field values, explicit queries, date ranges, numeric ranges or pivot

Core

• Dynamically create and delete document collections without restarting
• Pluggable query handlers and extensible XML data format
• Pluggable user functions for Function Query
• Customizable component based request handler with distributed search support
• Document uniqueness enforcement based on unique key field

Caching

• Configurable Query Result, Filter, and Document cache instances
• Pluggable Cache implementations, including a lock free, high concurrency implementation
• Cache warming in background
• Fast/small filter implementation
• User level caching with autowarming support

SolrCloud

• Centralized Apache ZooKeeper based configuration
• Automated distributed indexing/sharding - send documents to any node and it will be forwarded to correct shard
• Near Real-Time indexing with immediate push-based replication (also support for slower pull-based replication)
• Transaction log ensures no updates are lost even if the documents are not yet indexed to disk

Admin Interface

• Comprehensive statistics on cache utilization, updates, and queries
• Interactive schema browser that includes index statistics
• Replication monitoring
• SolrCloud dashboard with graphical cluster node status
• Full logging control
• Text analysis debugger, showing result of every stage in an analyzer

• is an agile and dynamic language for the Java Virtual Machine
• builds upon the strengths of Java but has additional power features inspired by languages like Python, Ruby and Smalltalk
• makes modern programming features available to Java developers with almost-zero learning curve
• provides the ability to statically type check and statically compile your code for robustness and performance
• supports Domain-Specific Languages and other compact syntax so your code becomes easy to read and maintain
• makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL
• increases developer productivity by reducing scaffolding code when developing web, GUI, database or console applications
• simplifies testing by supporting unit testing and mocking out-of-the-box
• seamlessly integrates with all existing Java classes and libraries
• compiles straight to Java bytecode so you can use it anywhere you can use Java

• Dynamic Development : Clojure is dynamic. That means that a Clojure program is not just something you compile and run, but something with which you can interact.
• Functional Programming : It provides the tools to avoid mutable state, provides functions as first-class objects, and emphasizes recursive iteration instead of side-effect based looping.
• Lisp : Clojure is a member of the Lisp family of languages. Many of the features of Lisp have made it into other languages, but Lisp\'s approach to code-as-data and its macro system still set it apart.
• Runtime Polymorphism : Clojure supports polymorphism at 3 levels.
• Concurrent Programming : Clojure simplifies multi-threaded programming in several ways. Because the core data structures are immutable, they can be shared readily between threads.
• Hosted on the JVM : Clojure is designed to be a hosted language, sharing the JVM type system, GC, threads etc. It compiles all functions to JVM bytecode.

• Derby has a small footprint -- about 2.6 megabytes for the base engine and embedded JDBC driver.
• Derby is based on the Java, JDBC, and SQL standards.
• Derby provides an embedded JDBC driver that lets you embed Derby in any Java-based solution.
• Derby also supports the more familiar client/server mode with the Derby Network Client JDBC driver and Derby Network Server
• Derby is easy to install, deploy, and use.

• High performance
• Real threading
• Vast array of libraries
• Ruby 1.8.7 and 1.9.3 compatible
• Both versions in single install
• Easy migration
• Easy to install
• No hassles

• CDI - Apache OpenWebBeans
• EJB - Apache OpenEJB
• JPA - Apache OpenJPA
• JSF - Apache MyFaces
• JSP - Apache Tomcat
• JSTL - Apache Tomcat
• JTA - Apache Geronimo Transaction
• Servlet - Apache Tomcat
• Javamail - Apache Geronimo JavaMail
• Bean Validation - Apache BVal
• JAX-RS - Apache CXF
• JAX-WS - Apache CXF
• JMS - Apache ActiveMQ
• Connector - Apache Geronimo Connector

1. Introduction - A brief, high level, overview of Apache Tomcat.
2. Setup - How to install and run Apache Tomcat on a variety of platforms.
3. First web application - An introduction to the concepts of a web application as defined in the Servlet Specification. Covers basic organization of your web application source tree, the structure of a web application archive, and an introduction to the web application deployment descriptor (/WEB-INF/web.xml).
4. Deployer - Operating the Apache Tomcat Deployer to deploy, precompile, and validate web applications.
5. Manager - Operating the Manager web app to deploy, undeploy, and redeploy applications while Apache Tomcat is running.
6. Realms and Access Control - Description of how to configure Realms (databases of users, passwords, and their associated roles) for use in web applications that utilize Container Managed Security.
7. Security Manager - Configuring and using a Java Security Manager to support fine-grained control over the behavior of your web applications.
8. JNDI Resources - Configuring standard and custom resources in the JNDI naming context that is provided to each web application.
9. JDBC DataSource - Configuring a JNDI DataSoure with a DB connection pool. Examples for many popular databases.
10. Classloading - Information about class loading in Apache Tomcat, including where to place your application classes so that they are visible.
11. JSPs - Information about Jasper configuration, as well as the JSP compiler usage.
12. SSL - Installing and configuring SSL support so that your Apache Tomcat will serve requests using the https protocol.
13. SSI - Using Server Side Includes in Apache Tomcat.
14. CGI - Using CGIs with Apache Tomcat.
15. Proxy Support - Configuring Apache Tomcat to run behind a proxy server (or a web server functioning as a proxy server).
16. MBean Descriptor - Configuring MBean descriptors files for custom components.
17. Default Servlet - Configuring the default servlet and customizing directory listings.
18. Apache Tomcat Clustering - Enable session replication in a Apache Tomcat environment.
19. Balancer - Configuring, using, and extending the load balancer application.
20. Connectors - Connectors available in Apache Tomcat, and native web server integration.
21. Monitoring and Management - Enabling JMX Remote support, and using tools to monitor and manage Apache Tomcat.
22. Logging - Configuring logging in Apache Tomcat.
23. Apache Portable Runtime - Using APR to provide superior performance, scalability and better integration with native server technologies.
24. Virtual Hosting - Configuring virtual hosting in Apache Tomcat.
25. Advanced IO - Extensions available over regular, blocking IO.
26. Additional Components - Obtaining additional, optional components.
27. Using Tomcat libraries with Maven - Obtaining Tomcat jars through Maven.
28. Security Considerations - Options to consider when securing an Apache Tomcat installation.
29. Windows Service - Running Tomcat as a service on Microsoft Windows.
30. Windows Authentication - Configuring Tomcat to use integrated Windows authentication.
31. High Concurrency JDBC Pool - Configuring Tomcat to use an alternative JDBC pool.
32. WebSocket support - Developing WebSocket applications for Apache Tomcat.

1. Bug Tracking And Wiki - In addition to doing distributed version control like Git and Mercurial, Fossil also supports distributed bug tracking, distributed wiki, and a distributed blog mechanism all in a single integrated package.

1. Web Interface - Fossil has a built-in and easy-to-use web interface that simplifies project tracking and promotes situational awareness. Simply type "fossil ui" from within any check-out and Fossil automatically opens your web browser in a page that gives detailed graphical history and status information on that project.

1. Autosync - Fossil supports "autosync" mode which helps to keep projects moving forward by reducing the amount of needless forking and merging often associated with distributed projects.

1. Self-Contained - Fossil is a single stand-alone executable that contains everything needed to do configuration management. Installation is trivial: simply download a precompiled binary for Linux, Mac, or Windows and put it on your $PATH. Easy-to-compile source code is available for users on other platforms. Fossil sources are also mostly self-contained, requiring only the standard C library to build.

1. Simple Networking - Fossil uses plain old HTTP (with proxy support) for all network communications, meaning that it works fine from behind restrictive firewalls. The protocol is bandwidth efficient to the point that Fossil can be used comfortably over a dial-up internet connection.

1. CGI/SCGI Enabled - No server is required to use fossil. But a server does make collaboration easier. Fossil supports four different yet simple server configurations. The most popular is a 2-line CGI script. This is the approach used by the self-hosting fossil repositories.

1. Robust & Reliable - Fossil stores content using an enduring file format in an SQLite database so that transactions are atomic even if interrupted by a power loss or system crash. Furthermore, automatic self-checks verify that all aspects of the repository are consistent prior to each commit. In over six years of operation, no work has ever been lost after having been committed to a Fossil repository.

Tags

OpenBD comes with a rich array of CFML tags, covering the core CFML language, as well as wonderful additions to the language that OpenBD has added to make your web development easier.

Functions

Functions are the life blood of the CFML language. Whether you are writing tag based applications, or CFSCRIPT based applications, there is a function waiting for you to do pretty much anything.

Bootstrap Application

Sometimes knowing where to start is the hardest thing, especially if you are new to the language. Do not worry, we can help. We have a bootstrap CFML site for you to get started and get up and running quickly.

• Supports a variety of Cross Language Clients and Protocols from Java, C, C++, C#, Ruby, Perl, Python, PHP .
• OpenWire for high performance clients in Java, C, C++, C#.
• Stomp support so that clients can be written easily in C, Ruby, Perl, Python, PHP, ActionScript/Flash, Smalltalk to talk to ActiveMQ as well as any other popular Message Broker.
• full support for the Enterprise Integration Patterns both in the JMS client and the Message Broker.
• Supports many advanced features such as Message Groups, Virtual Destinations, Wildcards and Composite Destinations.
• Fully supports JMS 1.1 and J2EE 1.4 with support for transient, persistent, transactional and XA messaging.
• Spring Support so that ActiveMQ can be easily embedded into Spring applications and configured using Spring\'s XML configuration mechanism.
• Tested inside popular J2EE servers such as TomEE, Geronimo, JBoss, GlassFish and WebLogic.
• Includes JCA 1.5 resource adaptors for inbound and outbound messaging so that ActiveMQ should auto-deploy in any J2EE 1.4 compliant server.
• Supports pluggable transport protocols such as in-VM, TCP, SSL, NIO, UDP, multicast, JGroups and JXTA transports
• Supports very fast persistence using JDBC along with a high performance journal.
• Designed for high performance clustering, client-server, peer based communication.
• REST API to provide technology agnostic and language neutral web based API to messaging.
• Ajax to support web streaming support to web browsers using pure DHTML, allowing web browsers to be part of the messaging fabric.
• CXF and Axis Support so that ActiveMQ can be easily dropped into either of these web service stacks to provide reliable messaging.
• Can be used as an in memory JMS provider, ideal for unit testing JMS.

Open Source Software - HornetQ is released under the Apache v 2.0 Licence.

Written in Java - HornetQ runs on any platform with a Java 5 or later runtime.

JMS and above - HornetQ supports the JMS 1.1 and 2.0 APIs and also defines its own messaging API for maximum performance and flexibility. Other protocols are planned for upcoming releases.

Superb performance - HornetQ class-beating high performance journal provides persistent messaging performance at rates normally seen for non-persistent messaging. Non-persistent messaging performance rocks the boat too.

POJO-based design - HornetQ has been designed using POJO and minimal third-party dependencies. You choose how you want to use HornetQ: run it stand-alone, integrate it with JBoss Application Server or another Java server/container or embed it directly inside your own product.

Solid high availability - HornetQ offers server replication and automatic client failover to eliminate lost or duplicated messages in case of server failure.

Flexible clustering - Create clusters of HornetQ servers that know how to load balance messages. Link geographically distributed clusters over unreliable connections to form a global network. Configure routing of messages in a highly flexible way. Adapt HornetQ to your network topology, not the other way round.

Management - HornetQ provides a comprehensive management API to manage & monitor servers. It is integrated seamlessly to the servers to work in a highly available environment.

Documentation & Examples - All HornetQ features are documented and examples are provided. Read the documentation, run the examples and leverage HornetQ features to make your messaging code more robust and performant.

Rack

TorqueBox supports Rack, including Rails 2.3.x, Rails 3.x, Sinatra, and others. Rack applications are served as first-class resources within the web container. The web container is clusterable, and web sessions may be shared between nodes without any additional configuration.

JDBC

High-performance tried-and-true Java Database Connectivity (JDBC) database drivers power your ActiveRecord and other database access.

Daemons

TorqueBox provides the framework to manage your daemon-like Ruby components. TorqueBox makes sure it starts and stops with your application. What you do in the middle is up to you.

Scheduled Jobs

Cron-like functionality is provided by the TorqueBox server. Job classes implemented in Ruby have full access to to your Ruby environment and are managed by a durable job scheduler.

Messaging

Your simple Ruby components can both produce and consume messages from clustered and distributed asynchronous messaging fabric powered by HornetQ.

Asynchronous Tasks

Leveraging the messaging system, TorqueBox makes it easy to execute simple tasks and methods asynchronously, allows your application to quickly return control to the user.

• Clustering
• Deployment API
• Distributed caching (using Infinispan, a standalone project)
• Distributed deployment
• Enterprise JavaBeans versions 3 and 2.1
• Failove (including Web and EJB sessions)
• Hibernate integration (for persistence programming; Java Persistence API> or JPA)
• Java Authentication and Authorization Service (JAAS)
• Java EE Connector Architecture (JCA) integration
• Java Management Extensions
• Java Message Service (JMS) integration
• Java Naming and Directory Interface (JNDI)
• Java Transaction API (JTA)
• Java Authorization Contract for Containers (JACC) integration
• JavaMail
• Java Server Faces 1.2 (Mojarra)
• Java Server Pages (JSP) / Java Servlet 2.1/2.5 (Tomcat)
• JBossWS (JBoss Web Services) for Java EE web services like JAX-WS
• JDBC
• Load balancing
• Management API
• OSGi framework
• RMI-IIOP (JacORB, contraction of Java and CORBA)
• SOAP with Attachments API for Java SAAJ)
• Teiid data virtualization system

Object-Oriented

• Scala is a pure-bred object-oriented language.

Functional

• Even though its syntax is fairly conventional, Scala is also a full-blown functional language.

Seamless Java Interop

• Scala runs on the JVM. Java and Scala classes can be freely mixed, no matter whether they reside in different projects or in the same.

Functions are Objects

• Scala\'s approach is to develop a small set of core constructs that can be combined in flexible ways.

Future-Proof

• Scala particularly shines when it comes to scalable server software that makes use of concurrent and synchronous processing, parallel utilization of multiple cores, and distributed processing in the cloud.

Fun

• Maybe most important is that programming in Scala tends to be very enjoyable. No boilerplate, rapid iteration, but at the same time the safety of a strong static type system.

built to kick ass

Erlang was developed at Ericsson and was designed from the ground up for writing scalable, fault-tolerant, distributed, non-stop, soft-realtime applications. Everything in the language, runtime and libraries reflects that purpose, which makes Erlang the best platform for developing this kind of software.

Use Erlang if you want your application to:

• handle very large number of concurrent activities
• be easily distributable over a network of computers
• be fault-tolerant to both software and hardware errors
• scale with the number of machines on the network
• be upgradable and reconfugurable without having to stop and restart
• be responsive to users within certain strict timeframes
• stay in continuous operation for many years

Because Erlang is oriented around concurrency, it\'s also naturally good at utilizing modern multicore systems.

Lightweight concurrency transparent distribution hot code replacement, and OTP are some of the specific features that make Erlang a joy to work with.

battle-proven

Erlang has been successfully used in production systems for over 20 years (with reported uptimes of 9-nines - that\'s 31ms of downtime a year). It\'s been proven to work well in both large-scale industrial software development, and in small agile teams in startups.

Ericsson themselves have used Erlang extensively for many projects of varying sizes, both commercial and internal. The AXD301 ATM, one of Ericsson\'s flagship products, may be the largest Erlang project in existence at over 1.1 million lines of Erlang.

Erlang users in the telecoms industry: Motorola, Nokia, T-Mobile, BT. Large software companies and startups: Amazon, Yahoo!, Facebook, Last.fm, Klarna, Tail-F, Github, Heroku, Engine Yard, MochiMedia. Open source projects: Flussonic, ejabberd, CouchDb, Riak, Disco, RabbitMQ, Dynomite.

saves time and money

Erlang lets you deliver kick-ass software faster, on smaller budgets and with smaller teams, and reduce TLC and TCO.

This is made possible by a number of reasons:

• The OTP libraries provide a complete set of easy-to-use components for building robust distributed applications, that have been used in hundreds of projects, and thouroughly tested and debugged over the last 10 years.
• A large number of high-quality open-source libraries is available for many other tasks, such as XML processing or interacting with database systems such as PostgreSQL. Interfacing with existing code in Java, C, Python or Ruby is straightforward too.
• Erlang code tends to be conscise and readable, which is made possible by the simplicity of the language and powerful abstraction mechanisms available.
• Erlang scales well to large and small teams, and makes both top-down and bottom-up approaches to building software natural.
• Erlang is easy to learn. An experienced programmer can start writing useful code after a couple of days of learning Erlang.
• Availability of high-quality tools such as documentation generators, testing frameworks, debuggers, graphical diagnostics tools, and IDEs.

easy to learn

Erlang has a simple and consistent core which makes it easy to pick up. Experienced programmers can start writing useful code after a couple of days with Erlang. There are no complicated concepts to understand or arcane theories to master. The syntax may look a little different if you\'re coming from Ruby, Python, or Java, but it doesn\'t take long to get used to.

In fact, making the language easy to pick up was one of the original design goals of the Erlang development team. Erlang is very pragmatic and has been made by working programmers, for working programmers.

lightweight concurrency

Processes are very lightweight, with only about 500 bytes of overhead per-process. This means that millions of processes can be created, even on older computers.

Because Erlang\'s processes are completely independent of OS processes (and aren\'t managed by the OS scheduler), your programs will behave in exactly the same way regardless of whether they run on Linux, FreeBSD, Windows or any of the other systems that Erlang runs on.

Because of Erlang\'s great support for concurrency it becomes natural to model applications around multiple independent communicating agents, which is just how things are in the real world.

hot code replacement

In a real-time control system we often don\'t want to stop the system in order to upgrade the code. In certain real-time control systems we may never be able to turn off the system to perform upgrades, and such systems have to be designed with dynamic code upgrades in mind. An example of such system is the X2000 satellite control system developed by NASA.

When you write your app in Erlang, you get dynamic code upgrade support for free when you use OTP. The mechanism itself is very straightforward and easy to understand.

This can save hundreds of hours of time in development:

This is a common Erlang development workflow:

1. Start the app.
2. Edit the code.
3. Recompile. (one keystroke)
4. That\'s it! There is no restart step. The app gets updated with the new code while it\'s running and tests get run automatically to ensure there are no regressions. This of course works great with TDD too.

transparent distribution

Erlang programs can be easily ported from a single computer to a network of computers. With the exception of timing all operations in the distributed system will work in exactly the same way as they worked in a single-node system.

OTP

OTP, the Open Telecom Platform, is a collection of standard libraries that distill years of real-world experience of building scalable, distributed, fault-tolerant applications.

• Tools to enable easy data extract/transform/load (ETL)
• A mechanism to impose structure on a variety of data formats
• Access to files stored either directly in Apache HDFS or in other data storage systems such as Apache HBase
• Query execution via MapReduce

More Operators

Stratosphere extends the well-known MapReduce model with new operators. These operators represent many common data analysis tasks more naturally and efficiently. All operators will start working in memory and gracefully go out of core under memory pressure.

Advanced Data Flow Graphs

Stratosphere allows to model analysis programs as advanced data flow graphs. For many applications, this is a more natural fit than the constrained MapReduce interface (strictly Map followed by Reduce). Furthermore, data pipelining and in-memory data transfers increase performance by drastically reducing disk and network I/O.

Powerful Programming Interfaces

You can write data analysis programs for Stratosphere in Java or Scala. Both APIs provide a powerful yet easy-to-use abstraction to compose data analysis programs by applying customizable transformations such as map, filter, reduce, and join on data sets. Stratosphere\'s high-level APIs hide the complexities of parallel programming and efficient data processing from the user. Behind the scenes, the Stratosphere optimizer compiles such programs into efficient, parallel data flows which are executed on a cluster or a local machine.

Support for Iterative Algorithms

Data Mining, Machine Learning and Graph processing algorithms often require to loop over the working data multiple times. Stratosphere supports iterative algorithms in its core. (The runtime allows for very fast iteration times and the optimizer deals with caching loop-invariant data.) The advanced incremental iterations support algorithms that focus on the "hot part" of the evolving solution and may converge even faster.

High-Performance Execution Runtime

Stratosphere features its own high-performance, massively-parallel execution runtime which has been built from ground up leveraging processing techniques of parallel database systems. The engine supports low-latency processing concepts such as pipelined execution, in-memory processing, and push-based data shipping as well as sort- and hash-based processing algorithms which go gracefully out-of-core if main memory is not sufficient.

Built-In Optimizer

Stratosphere comes with an optimizer that is independent of the actual programming interface. It chooses a fitting execution strategy depending on the inputs and operations. For example the "Join" operator will choose between partitioning and broadcasting the data, as well as between running a sort-merge-join or a hybrid hash join algorithm.

System Stack

Stratosphere seamlessly integrates into existing Hadoop setups and runs side-by-side with Hadoop\'s TaskTrackers and DataNodes. Stratosphere can read data from Hadoop sources, but comes with its own efficient runtime. Similar to Hadoop, Stratosphere scales by adding more machines to the cluster. Stratosphere runs also on Hadoop 2.2 (YARN), so you do not need to change your infrastructure. The Local execution mode allows to debug and analyze your application right from your favorite IDE, without having Stratosphere installed.

Open Source Community and Support

Stratosphere is an active, community driven open-source project. It is licensed under the Apache License. Our friendly community is always open to new users and developers. Join us and shape the future of Big Data.

• 100% pure Java Object Oriented Database Management System (ODBMS).
• No proprietary API - managed only by standard Java APIs (JPA 2 / JDO 2).
• Extremely fast - faster than any competitive JPA / JDO product.
• Suitable for database files ranging from kilobytes to terabytes.
• Supports both Client-Server mode and Embedded (in process) mode.
• Single JAR with no external dependencies.
• Database is stored as a single file.
• Advanced querying and indexing capabilities.
• Effective in heavy loaded multi user environment.
• Can easily be embedded in applications of any type and size.
• Tested with Tomcat, Jetty, GlassFish, JBoss and Spring.

1. Support for Java Servlet 3.1, JavaServer Pages 2.3, Java Unified Expression Language 3.0 and Java WebSocket 1.0.
2. The default connector implementation is now the Java non-blocking implementation (NIO) for both HTTP and AJP.
3. A new resources implementation that replaces Aliases, VirtualLoader, VirtualDirContext, JAR resources and external repositories with a single, consistent approach for configuring additional web application resources. The new resources implementation can also be used to implement overlays (using a master WAR as the basis for multiple web applications that each have their own customizations).

• Event-Driven Architecture
• Understands Apache Rewrite Rules
• Friendly Admin Interfaces
• Built for Speed and Security
• Intelligent Cache Acceleration
• PageSpeed Optimization
• PHP LiteSpeed SAPI
• WordPress Acceleration

• Monitor files and directories for changes and send an email report of activity
• IP Reputation System. The system provides a variety of IP blocklists gathered from information that is submitted by participating servers. This dual aspect provides the information to help protect the server using the reputation from active attacks
• Major update to Script Version Scanning. cxs now scans for more than 200 individual applications, more than 200 WordPress plugins and more than 200 Joomla Extensions. Over 700 in total!
• cxs Setup Wizard to the UI for easy first-time configuration
• cxs Command Wizard to help create effective scan commands
• new quarantine interface via an SQLite database
• statistics to provide information at a glance as to what cxs has been doing
• command Wizards to help configure cxs Watch and Modsecurity
• cxs Daily/Weekly Scan Wizard, to create and modify cron jobs in /etc/cron.d/cxs-cron
• EXPERIMENTAL support for RHEL v7.* fanotify and CloudLinux v7.* File Change API

PostgreSQL prides itself in standards compliance. Its SQL implementation strongly conforms to the ANSI-SQL:2008 standard. It has full support for subqueries (including subselects in the FROM clause), read-committed and serializable transaction isolation levels. And while PostgreSQL has a fully relational system catalog which itself supports multiple schemas per database, its catalog is also accessible through the Information Schema as defined in the SQL standard.

Data integrity features include (compound) primary keys, foreign keys with restricting and cascading updates/deletes, check constraints, unique constraints, and not null constraints.

It also has a host of extensions and advanced features. Among the conveniences are auto-increment columns through sequences, and LIMIT/OFFSET allowing the return of partial result sets. PostgreSQL supports compound, unique, partial, and functional indexes which can use any of its B-tree, R-tree, hash, or GiST storage methods.

GiST (Generalized Search Tree) indexing is an advanced system which brings together a wide array of different sorting and searching algorithms including B-tree, B+-tree, R-tree, partial sum trees, ranked B+-trees and many others. It also provides an interface which allows both the creation of custom data types as well as extensible query methods with which to search them. Thus, GiST offers the flexibility to specify what you store, how you store it, and the ability to define new ways to search through it --- ways that far exceed those offered by standard B-tree, R-tree and other generalized search algorithms.

GiST serves as a foundation for many public projects that use PostgreSQL such as OpenFTS and PostGIS. OpenFTS (Open Source Full Text Search engine) provides online indexing of data and relevance ranking for database searching. PostGIS is a project which adds support for geographic objects in PostgreSQL, allowing it to be used as a spatial database for geographic information systems (GIS), much like ESRI\'s SDE or Oracle\'s Spatial extension.', 'space' => '28538880', 'support' => 'http://www.postgresql.org/support/', 'version' => '16.2', 'category' => 'databases', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => 'logo.gif', 'description' => 'PostgreSQL is a powerful, open source object-relational database system. It has more than 15 years of active development and a proven architecture that has earned it a strong reputation for reliability, data integrity, and correctness. It runs on all major operating systems, including Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64), and Windows. It is fully ACID compliant, has full support for foreign keys, joins, views, triggers, and stored procedures (in multiple languages). It includes most SQL:2008 data types, including INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE, INTERVAL, and TIMESTAMP. It also supports storage of binary large objects, including pictures, sounds, or video. It has native programming interfaces for C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC, among others.', 'desc' => 'PostgreSQL is a powerful, open source object-relational database system. It has more than 15 years of active development and a proven architecture that has earned it a strong reputation for reliability, data integrity, and correctness. It runs on all major operating systems, including Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64), and Windows. It is fully ACID compliant, has full support for foreign keys, joins, views, triggers, and stored procedures (in multiple languages). It includes most SQL:2008 data types, including INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE, INTERVAL, and TIMESTAMP. It also supports storage of binary large objects, including pictures, sounds, or video. It has native programming interfaces for C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC, among others.', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'pgsql16-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '8', 'release_date' => '08-02-2024', 'md5' => '', 'urlname' => 'PostgreSQL16', ), 204 => array ( 'aid' => '204', 'name' => 'Node.js 20', 'softname' => 'nodejs20', 'fullname' => 'Node.js 20', 'type' => 'app', 'group_type' => NULL, 'webuzo_version' => '', 'overview' => 'Node.js 14is a platform built on Chrome\'s JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.', 'features' => 'Node\'s goal is to provide an easy way to build scalable network programs Node.js contains a built-in HTTP server library, making it possible to run a web server without the use of external software, such as Apache or Lighttpd, and allowing more control of how the web server works. Node.js enables web developers to create an entire web application in JavaScript, both server-side and client-side', 'space' => '86487040', 'support' => 'http://nodejs.org/', 'version' => 'v20.10.0', 'category' => 'web_servers', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => 'logo.gif', 'description' => 'Node.js 20 is a platform built on Chrome\'s JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices', 'desc' => 'Node.js 20 is a platform built on Chrome\'s JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'nodejs20-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '1', 'release_date' => '22-11-2023', 'md5' => '', 'urlname' => 'Node.js_20', ), 205 => array ( 'aid' => '205', 'name' => 'PHP 8.3', 'softname' => 'php83', 'fullname' => 'PHP 8.3', 'type' => 'app', 'group_type' => 'php', 'webuzo_version' => '', 'overview' => 'PHP 8.3 is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. If you are new to PHP and want to get some idea of how it works, try the introductory tutorial. After that, check out the online manual. Ever wondered how popular PHP is? See the Netcraft Survey.', 'features' => 'PHP includes free and open source libraries with the core build. PHP is a fundamentally Internet-aware system with modules built in for accessing File Transfer Protocol (FTP) servers, many database servers, embedded SQL libraries such as embedded PostgreSQL, MySQL, Microsoft SQL Server and SQLite, LDAP servers, and others. Many functions familiar to C programmers such as those in the stdio family are available in the standard PHP build. PHP allows developers to write extensions in C to add functionality to the PHP language. These can then be compiled into PHP or loaded dynamically at runtime. Extensions have been written to add support for the Windows API, process management on Unix-like operating systems, multibyte strings (Unicode), cURL, and several popular compression formats. Other features include integration with IRC, dynamic generation of images and Adobe Flash content, and even speech synthesis. The language\\\'s core functions such as those dealing with strings and arrays are also implemented as an extension. The PHP Extension Community Library (PECL) project is a repository for extensions to the PHP language.', 'space' => '442644480', 'support' => 'http://www.php.net/', 'version' => '8.3.4', 'category' => 'server_side_scripting', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => 'logo.gif', 'description' => 'PHP 8.3 is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. If you are new to PHP and want to get some idea of how it works, try the introductory tutorial. After that, check out the online manual. Ever wondered how popular PHP is? See the Netcraft Survey.', 'desc' => 'PHP 8.3 is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. If you are new to PHP and want to get some idea of how it works, try the introductory tutorial. After that, check out the online manual. Ever wondered how popular PHP is? See the Netcraft Survey.', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'php83-x86_64.zip', 'major' => '0', 'mod' => '3', 'mod_files' => '9', 'release_date' => '14-03-2024', 'md5' => '', 'urlname' => 'PHP_8.3', ), 209 => array ( 'aid' => '209', 'name' => 'PGSQL-common', 'softname' => 'pgsql-common', 'fullname' => 'PGSQL-COMMON', 'type' => 'library', 'group_type' => NULL, 'webuzo_version' => '', 'overview' => NULL, 'features' => NULL, 'space' => '0', 'support' => '', 'version' => '1.x', 'category' => '', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => '', 'description' => 'pgsql-common package is used by all pgsql packages', 'desc' => 'pgsql-common package is used by all pgsql packages', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'pgsql-common-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '12', 'release_date' => '24-02-2023', 'md5' => '', 'urlname' => 'PGSQL-common', ), 208 => array ( 'aid' => '208', 'name' => 'Dotnet', 'softname' => 'dotnet', 'fullname' => 'Dotnet', 'type' => 'app', 'group_type' => NULL, 'webuzo_version' => '', 'overview' => '.NET is a free, cross-platform, open-source developer platform for building many kinds of applications. .NET is built on a high-performance runtime that is used in production by many high-scale apps.', 'features' => '.NET is a free, cross-platform, open-source developer platform for building many kinds of applications. .NET is built on a high-performance runtime that is used in production by many high-scale apps.', 'space' => '629145600', 'support' => 'https://dotnet.microsoft.com/en-us/platform/support', 'version' => '8.x', 'category' => 'web_servers', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => 'logo.gif', 'description' => '.NET is a free, cross-platform, open-source developer platform for building many kinds of applications. .NET is built on a high-performance runtime that is used in production by many high-scale apps.', 'desc' => '.NET is a free, cross-platform, open-source developer platform for building many kinds of applications. .NET is built on a high-performance runtime that is used in production by many high-scale apps.', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'dotnet-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '1', 'release_date' => '10-10-2024', 'md5' => '', 'urlname' => 'Dotnet', ), 211 => array ( 'aid' => '211', 'name' => 'MariaDB 11.2', 'softname' => 'mariadb112', 'fullname' => 'MariaDB 11.2', 'type' => 'service', 'group_type' => 'mysql', 'webuzo_version' => '', 'overview' => 'MariaDB is a drop-in replacement for MySQL.', 'features' => 'MariaDB strives to be the logical choice for database professionals looking for a robust, scalable, and reliable SQL server. To accomplish this, Monty Program works to hire the best and brightest developers in the industry, work closely and cooperatively with the larger community of users and developers in the true spirit of Free and open source software, and release software in a manner that balances predictability with reliability.', 'space' => '0', 'support' => 'https://mariadb.org/en/', 'version' => '11.2.3', 'category' => 'databases', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => '', 'description' => 'MariaDB is a drop-in replacement for MySQL.\'', 'desc' => 'MariaDB is a drop-in replacement for MySQL.\'', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'mariadb112-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '4', 'release_date' => '08-02-2024', 'md5' => '', 'urlname' => 'MariaDB_11.2', ), 212 => array ( 'aid' => '212', 'name' => 'MariaDB 11.3', 'softname' => 'mariadb113', 'fullname' => 'MariaDB 11.3', 'type' => 'service', 'group_type' => 'mysql', 'webuzo_version' => '', 'overview' => 'MariaDB is a drop-in replacement for MySQL.', 'features' => 'MariaDB strives to be the logical choice for database professionals looking for a robust, scalable, and reliable SQL server. To accomplish this, Monty Program works to hire the best and brightest developers in the industry, work closely and cooperatively with the larger community of users and developers in the true spirit of Free and open source software, and release software in a manner that balances predictability with reliability.', 'space' => '0', 'support' => 'https://mariadb.org/en/', 'version' => '11.3.2', 'category' => 'databases', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => '', 'description' => 'MariaDB is a drop-in replacement for MySQL.', 'desc' => 'MariaDB is a drop-in replacement for MySQL.', 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'mariadb113-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '4', 'release_date' => '19-02-2024', 'md5' => '', 'urlname' => 'MariaDB_11.3', ), 213 => array ( 'aid' => '213', 'name' => 'Icu69', 'softname' => 'icu69', 'fullname' => 'Icu69', 'type' => 'library', 'group_type' => NULL, 'webuzo_version' => '', 'overview' => NULL, 'features' => NULL, 'space' => '43376640', 'support' => 'https://github.com/unicode-org/icu', 'version' => '69.1', 'category' => 'libraries', 'ratings' => '0.000', 'votes' => '0', 'reviews' => '0', 'logo' => 'logo.gif', 'description' => NULL, 'desc' => NULL, 'approved' => '1', 'ins' => 1, 'parent' => '', 'file' => '', 'file64' => 'icu69-x86_64.zip', 'major' => '0', 'mod' => '1', 'mod_files' => '1', 'release_date' => '07-04-2021', 'md5' => '', 'urlname' => 'Icu69', ), ); ?>