[[Software-development::programming-language]]

Ivy-Python: Links & maintainer email broken. Changed homepage to archive.org link. Poppy-one (talk) 12:26, 6 August 2018 (EDT) Ivy is a lightweight software bus for quick-prototyping protocols. It allows applications to broadcast information through text messages, with a subscription mechanism based on regular expressions.

JCIFS: 'jCIFS' is an SMB client library that follows the CIFS specification supporting Unicode, named pipes, batching, multiplexing IO of threaded callers, encrypted authentication, full transactions, domain/workgroup/host/share/file enumeration, NetBIOS sockets and name services, the smb:// URL protocol handler, a java.io.File like API, RAP calls, NTLM HTTP Authentication, and more.

JDEE: The Java Development Environment for Emacs (JDEE) is an add on software package for Emacs that assists in the development of software in the Java Programming Language. JDEE provides many Emacs commands that help with editing, compiling, running, debugging, and browsing large Java programs.

JQuery Autocompleter: I modeled this autocompleter to be as *simple* as possible. From a higher level, and autocompleter is nothing more than a submission of the contents of a single form field to a url, and then displaying the results.

JRuby: Ruby is the effort to recreate the Ruby interpreter in Java. JRuby is tightly integrated with Java to allow both to script any Java class and to embed the interpreter into any Java application. The package includes a Ruby 1.6.7 compatible interpreter (not all builtin classes are supported yet), support for scripting Java classes and interfaces in JRuby, and Bean Scripting Framework (BSF) support.

JSON Storage Access Methods is a library for storage and retrieval of JavaScript Object Notation (JSON) encoded objects. Backends include:

file: directory of plain text JSON files
rcs: directory of plain text JSON files under RCS
cvs: directory of plain text JSON files under CVS (not tested)
svn: directory of plain text JSON files under SVN (not tested)
sqlite: object trees stored in an SQLite3 database
mysql: object trees stored in a MySQL database (barely tested)
Lookup methods include:
Collections: a jQuery-like method-chained interface
XPath-like query language (only supported for SQL backends)

JSBundle: jsBundle is a python project that gathers and builds javascript libraries into single files, minified, documented, and even gathers test files. The built files can optionally include a hash in their filenames to ensure browsers don't continue to cache through versions.

JSONPath: JSONPath is an XPath-like tool for JSON.

JSONgrep: JSONgrep is a shell tool for extracting values from JSON documents. It supports shell-like globbing for property names, and emits the matched values separated by newlines.

JSONlib2: This is yet another library for reading/writing json. The goal is to be API compatible with simplejson, except that it is written purely in C and is thus 5x-20x faster for both encoding and decoding, depending on the data.

JZlib: JZlib is a re-implementation of zlib in pure Java. The first and final aim for hacking this was to add packet compression support to pure Java SSH systems. It can inflate and deflate zlib data, but does not yet support gzip file handling supports. It does support all compression levels and flushing modes in zlib.

Jack: Jack is a console based cd-ripper. It supports cdparanoia and cdda2wav (amongst others) for extraction and various MP3 and OGG/Vorbis encoders; you can even rip from a cdrdao-generated CD image. Emphasis is on failure-safeness and ease of use. Jack can encode multiple tracks at once, good on SMP systems. It resumes its work if interrupted and keeps an eye on available HD space. It also supports freedb query at any time, even after encoding, and can try to query freedb for MP3s of which you do not know the CD anymore (provided you have a complete rip and know the track sequence).

Janet: Janet is a functional and imperative programming language. It runs on Windows, Linux, macOS, BSDs, and should run on other systems with some porting. The entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB. You can also add Janet scripting to an application by embedding a single C source file and a single header.

Java-gnome: Java-GNOME is a Java binding for GTK and GNOME. It is implemented as a JNI layer that delegates the Java calls to the underlying native libraries.

Jekyll: Jekyll is a simple, blog aware, static site generator. It takes a template directory (representing the raw form of a website), runs it through Textile or Markdown and Liquid converters, and spits out a complete, static website suitable for serving with Apache or your favorite web server. This is also the engine behind GitHub Pages, which you can use to host your project's page or blog right from GitHub.

Jeweler

Jeweler: Craft the perfect RubyGem Jeweler provides two things:

Rake tasks for managing gems and versioning of a GitHub project
A generator for creating/kickstarting a new project

Jimtcl: Jim is a small-footprint implementation of the Tcl programming language. It implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, first-class arrays and UTF-8 support. All this with a binary size of about 100-200kB (depending upon selected options). This package provides the Jim interactive shell.

Jinja: Jinja is a sandboxed template engine written in pure Python. It provides a Django like non-XML syntax and compiles templates into executable python code. It's basically a combination of Django templates and python code.

JobLib

A set of tools to run Python scripts as jobs; namely: persistence and lazy re-evaluation (between make and the memorize pattern), logging, and tools for reusing scripts. Joblib provides a set of tools to run Python scripts as jobs; namely:

1. persistence and lazy re-evaluation (between make and the memorize pattern),
2. logging,
3. tools for reusing scripts.
The original focus was on scientific-computing scripts, but any long-running succession of operations can profit from the tools provided by joblib.

Jquery Infinite Scroll: A basic infinite scrolling pattern for jQuery.

Jquery Livesearch: Adds some live search to your web page.

JsonPickle: Python library for serializing any arbitrary object graph into JSON. It can take almost any Python object and turn the object into JSON. Additionally, it can reconstitute the object back into Python.

Jtw: Java Training wheels (J.T.W.) provides a less steep learning curve for learning to program in Java. The system is powered by a preprocessor that adds features to Java such as a superfor macro and a file inclusion system much like the C language's preprocessor.

Jug: Jug allows you to write code that is broken up into tasks and run different tasks on different processors. It has two storage backends: One uses the filesystem to communicate between processes and works correctly over NFS, so you can coordinate processes on different machines. The other uses a redis database and all it needs is for different processes to be able to communicate with a common redis server. Jug is a pure Python implementation and should work on any platform.

Kaffe: Kaffe is a clean room implementation of the Java virtual machine, plus the associated class libraries needed to provide a Java runtime environment. As an independent implementation, it was written from scratch and is free from all third party royalties and license restrictions. It comes with its own standard class libraries, including Beans and Abstract Window Toolkit (AWT), native libraries, and a highly configurable virtual machine with a just-in-time (JIT) compiler for enhanced performance.

Karrigell: 'Karrigell' is a Web programming application that includes a Web server and an SQL database (gadfly). It allows execution of Python scripts and of pages mixing Python and HTML, easy handling of authentication and sessions, building pages from components, and internationalization features. It comes with a complete documentation and several demos, including a wiki server, a forum, and a portal with personalization and news editing.

Kawa: Kawa is both a full-featured Scheme implementation, and a compiler toolkit for implementing other programming languages. It currently compiles the Scheme functional language to Java bytecodes. Included in Kawa is qexo, a partial implementation of XQuery in Java.

Kedama: A wrapper around ming. Create swf files in ruby using ming.

Keyword Search: Generic support for extracting GMail-style search keywords/values from strings.

Kite: Kite is a programming language designed to minimize as much of the programmer experience as possible — quick development, fast execution with low CPU and memory usage. Of course, there's more to kite than that, so lets get started on a real introduction. On being unique Kite's syntax is different from most languages, if you're used to your curly braces, indented blocks or end statements, you're in for a little surprise. But hey, cheer up, change is good!

Kiwi: Kiwi consists of a set of classes and wrappers for PyGTK that were developed to provide a sort of framework for applications. Fully object-oriented, and roughly Smalltalk's MVC, Kiwi provides a simple, practical way to build forms, windows and widgets that transparently access and display your object data. Kiwi was primarily designed to make implementing the UI for Stoq easier.

Klisp: klisp is an interpreter for the Kernel Programming Language. It aims at being comprehensive and robust as specified in the "Revised(-1) Report on the Kernel Programming Language (revised 29 October 2009)". Kernel Programming Language is a Scheme-like dialect of Lisp in which everything is a first-class object. It features first class environments and statically scoped fexprs (called operatives). It was designed by John N. Shutt. You can read all about it at http://web.cs.wpi.edu/~jshutt/kernel.html klisp is developed by Andres Navarro, a Computer Science undergraduate at Buenos Aires University (UBA). You can reach him at canavarro82@gmail.com. Significant contributions are being made by Oto Havle in his fork over at https://bitbucket.org/havleoto/klisp

Kook: Kook is a very useful tool to control your task such as compile, install or clean. Kook is similar to Make, Rake, Ant, or Cook. Kookbook.py, is a task definition file for Kook.

Kwartz: Kwartz is a template system which realized the concept of 'Independence of Presentation Logic'(IoPL). It is available to separate the presentation layer from the main program with any template system. In addition, Kwartz enables you to separate the presentation logic (such as iteration or conditional branching) from the presentation data (HTML file).

Kxparse: KXParse is a PHP-based, lightweight, easy-to-use XML parser. It's an include file that's loaded on the fly, so it does not need to be installed.

LISA: 'LISA' is a platform for the development of Lisp-based Intelligent Software Agents. It is a production-rule system implemented in the Common Lisp Object System (CLOS), and is heavily influenced by CLIPS and the Java Expert System Shell (JESS). Its core is a reasoning engine based on an object-oriented implementation of the Rete algorithm solving the many-to-many matching problem. LISA can reason over CLOS objects without imposing special class hierarchy requirements, so users cans augment existing CLOS applications with reasoning capabilities. Also, the full power of Common Lisp is available for use within productions; there is no dichotomy between the programming language and its implementation. The project's goals include complete freedom of availability, ease of portbility, simplicity (so that new developers can easily understand code layout and behavior), familiarity (with roots in CLIPS and JESS, LISA will be familiar to those who've worked with these systems), and flexibility.

LWebstring: * webstring replaces the standalone packages webstring, lwebstring, TurboWebstring, and LturboWebstring. lxml-based implementation of webstring, an XML template engine. An lxml-based implementation of webstring, an XML template engine where Python is the template language.

LXML: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API. lxml is a Pythonic, mature binding for the libxml2 and libxslt libraries. It provides safe and convenient access to these libraries using the ElementTree API. It extends the ElementTree API significantly to offer support for XPath, RelaxNG, XML Schema, XSLT, C14N and much more.

Latte: Latte is a true designer-friendly templating language for PHP. Latte compiles template down to the optimal PHP code at the same time as you work. It provides support for creating layouts, blocks, template inheritance, autoescaping, and other features. It is a particularly safe templating system that prevents threats of XSS with context-aware escaping. Latte protects your work from many security traps.

LavaPE: 'LavaPE' is a programming environment for the experimental object-oriented programming language Lava. It replaces text editing with structure editing, thereby preventing all syntactic and many semantic errors. The pure point-and-click nature of Lava programming and the concise representation of programs as declaration trees with small chunks of executable code simplify programming, and ease comprehension.

Lib rHarris: A Python Internet Programming Library. lib_rharris is a modest Python library for pulling, parsing and pickling remote web page data and for related net-aware tasks.

LibTPT: TPT is a template scripting language implemented in C++ and designed to be integrated with C++ programs. The TPT interpreter runs in one pass, so there is no expensive compilation stage. The language relies on C++ for I/O, making TPT portable, small, and fast. There are no bulky modules to include. TPT does not execute as a program or script. The LibTPT parser transforms TPT templates into text. The parser, which integrates with your C++ code through a simple class API, is small and fast, focusing on functionality instead of rich feature sets. Uses include on-the-fly HTML, source code generation, or in any situation where there is a need to generate customized text.

Liberty-eiffel: Liberty Eiffel is a compiler for the Eiffel programming language. It continues the development of SmartEiffel, the GNU Eiffel Compiler. It is a complete, small and fast, Eiffel compiler, including an Eiffel to C compiler, documentation tools, a pretty printer, a debugger and various other tools. It also includes a large library of classes distributed under the terms of the MIT/X Consortium License and a comprehensive set of wrappers/bindings for widespread Free-Software libraries. Eiffel is an advanced object-oriented programming language that emphasizes the design and construction of high-quality and reusable software.

Libixp

libixp is a stand-alone client/server 9P library including ixpc client. It consists of less than 2000 lines of code (including ixpc). libixp's server API is based heavily on that of Plan 9's lib9p, and the two libraries export virtually identical data structures. There are a few notable differences between the two, however:

libixp multiplexes connections internally, while on Plan 9, the kernel performs this task, and in plan9port, a separate process is spawned to do so. Despite this divergence, the user of the library will not notice any difference in behavior, except that there may be duplicate tag and fid numbers between different connections. This issue is of little relevance, however, as the library handles the task of mapping fids and tags to arbitrary pointers and P9Req structs.
libixp is released under a lenient MIT-style license, with the exception of the file intmap.c, which comes from Plan 9, and falls under the LPL. This file may be rewritten at some point, but the authors, as of yet, has been uncompelled to do so
.
libixp lacks lib9p's file trees.
Unlike plan9port's lib9p, libixp is POSIX based, and should compile without specialized libraries on nearly any POSIX system.

Lighttpdrecipe: Buildout recipe for generating Lighttpd configuration files This recipe for buildout generates Lighttpd configuration files. It's especially well suited for using with Django (djangorecipe) in FastCGI mode. Config file is generated from Jinja2 template. Recipe provides some custom Jinja tests, specifically tailored for Lighttpd configuration files. Very little logic is hard coded in the python code, most of the work happens in the template, so you can extend default template or even use your own.

Lightweight C++: 'lwc' is a programming language that looks like C++ and is directly translated to readable C code. It supports function overloading, member functions, inheritance, polymorphism (virtual functions), multiple inheritance, virtual inheritance and pure virtual functions, constructors/destructors, new/delete, and simplistic templates. By studying the generated C code it is easy to understand how OOP features are implemented and what is the cost of everything. Adding new features and extensions is also very easy (much easier than adding new C++ extensions to gcc at least).

LineProfiler: line_profiler will profile the time individual lines of code take to execute. The profiler is implemented in C via Cython in order to reduce the overhead of profiling. Also included is the script kernprof.py which can be used to conveniently profile Python applications and scripts either with line_profiler or with the function-level profiling tools in the Python standard library.

Lionet: This is a candidate for deletion: 1. No files sources found. A Django application for serving pickle-built Sphinx docs.

Lisp-cgi-utils: 'lisp-cgi-utils' is a package for developing CGI scripts with Common Lisp. It implements a very basic HTTP/CGI interface (sending headers, getting GET/POST and environment variables) and offers tools for easier HTML generation with special support for handling HTML forms.

Littler: Littler provides hash-bang (i.e. script starting with #!/some/path) capability for GNU R, as well as simple command-line and piping use.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools