<feed xmlns='http://www.w3.org/2005/Atom'>
<title>pkgsrc/lang, branch TNF</title>
<subtitle>[no description]</subtitle>
<id>https://git.osdyson.ru/mirror/pkgsrc/atom?h=TNF</id>
<link rel='self' href='https://git.osdyson.ru/mirror/pkgsrc/atom?h=TNF'/>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/'/>
<updated>2015-01-17T17:50:23Z</updated>
<entry>
<title>Initial import of Lua 5.3.0.</title>
<updated>2015-01-17T17:50:23Z</updated>
<author>
<name>alnsn</name>
<email>alnsn@pkgsrc.org</email>
</author>
<published>2015-01-17T17:50:23Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=5fab684ef860347eb961ccc5e1138d5863e25d75'/>
<id>urn:sha1:5fab684ef860347eb961ccc5e1138d5863e25d75</id>
<content type='text'>
Lua is a powerful, light-weight programming language designed for
extending applications. Lua is also frequently used as a
general-purpose, stand-alone language.

Lua combines simple procedural syntax (similar to Pascal) with
powerful data description constructs based on associative arrays and
extensible semantics. Lua is dynamically typed, interpreted from
bytecodes, and has automatic memory management, making it ideal for
configuration, scripting, and rapid prototyping.

Lua is a language engine that you can embed into your application.
This means that, besides syntax and semantics, Lua has an API that
allows the application to exchange data with Lua programs and also to
extend Lua with C functions. In this sense, Lua can be regarded as a
language framework for building domain-specific languages.

Lua is implemented as a small library of C functions, written in ANSI
C, and compiles unmodified in all known platforms. The implementation
goals are simplicity, efficiency, portability, and low embedding cost.
The result is a fast language engine with small footprint, making it
ideal in embedded systems too.</content>
</entry>
<entry>
<title>Initial import of nuitka-0.5.0.1 into the packages collection.</title>
<updated>2014-01-29T01:14:31Z</updated>
<author>
<name>agc</name>
<email>agc@pkgsrc.org</email>
</author>
<published>2014-01-29T01:14:31Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=f4cd6dda0d5c28070f544bfae68cc11bc5765c57'/>
<id>urn:sha1:f4cd6dda0d5c28070f544bfae68cc11bc5765c57</id>
<content type='text'>
Nuitka is a Python to C++ compiler

	Right now Nuitka is a good replacement for the Python interpreter and
	compiles every construct that CPython 2.6, 2.7, 3.2 and 3.3 offer.  It
	translates the Python into a C++ program that then uses "libpython" to
	execute in the same way as CPython does, in a very compatible way.

	It is somewhat faster than CPython already, but currently it doesn't
	make all the optimizations possible, but a 258% factor on pystone is a
	good start (number is from version 0.3.11).</content>
</entry>
<entry>
<title>Import LuaJIT version 2.0.2.</title>
<updated>2013-07-14T21:42:00Z</updated>
<author>
<name>alnsn</name>
<email>alnsn@pkgsrc.org</email>
</author>
<published>2013-07-14T21:42:00Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=87a016442ccbadc6f1dc09147df5e93a76892d74'/>
<id>urn:sha1:87a016442ccbadc6f1dc09147df5e93a76892d74</id>
<content type='text'>
LuaJIT is a Just-In-Time Compiler (JIT) for the Lua programming language.
Lua is a powerful, dynamic and light-weight programming language. It may
be embedded or used as a general-purpose, stand-alone language.</content>
</entry>
<entry>
<title>Import Armed Bear Common Lisp 1.0.1 as lang/abcl</title>
<updated>2012-08-08T20:24:44Z</updated>
<author>
<name>asau</name>
<email>asau@pkgsrc.org</email>
</author>
<published>2012-08-08T20:24:44Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=5da7586b330e0b35af577e3e36c36879cd977d3b'/>
<id>urn:sha1:5da7586b330e0b35af577e3e36c36879cd977d3b</id>
<content type='text'>
Armed Bear Common Lisp (ABCL) is a full implementation of
the Common Lisp language featuring both an interpreter and
a compiler, running in the JVM. Originally started to be
a scripting language for the J editor, it now supports JSR-223
(Java scripting API): it can be a scripting engine in any Java
application. Additionally, it can be used to implement (parts of)
the application using Java to Lisp integration APIs.</content>
</entry>
<entry>
<title>Import python32-3.2.3 as lang/python32.</title>
<updated>2012-05-06T13:12:09Z</updated>
<author>
<name>obache</name>
<email>obache@pkgsrc.org</email>
</author>
<published>2012-05-06T13:12:09Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=9cc5020705b105588392d0836686b5bcba66c399'/>
<id>urn:sha1:9cc5020705b105588392d0836686b5bcba66c399</id>
<content type='text'>
Python is an interpreted, interactive, object-oriented
programming language that combines remarkable power with
very clear syntax. For an introduction to programming in
Python you are referred to the Python Tutorial. The
Python Library Reference documents built-in and standard
types, constants, functions and modules. Finally, the
Python Reference Manual describes the syntax and semantics
of the core language in (perhaps too) much detail.

Python's basic power can be extended with your own modules
written in C or C++. On most systems such modules may be
dynamically loaded. Python is also adaptable as an exten-
sion language for existing applications. See the internal
documentation for hints.

This package provides Python version 3.2.x.</content>
</entry>
<entry>
<title>Import clojure-1.4.0 as lang/clojure.</title>
<updated>2012-05-04T11:51:30Z</updated>
<author>
<name>ryoon</name>
<email>ryoon@pkgsrc.org</email>
</author>
<published>2012-05-04T11:51:30Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=ffc79eedecc24de69d1d0ebe9a80d303dec60b1a'/>
<id>urn:sha1:ffc79eedecc24de69d1d0ebe9a80d303dec60b1a</id>
<content type='text'>
Clojure is a dynamic programming language that targets the Java
Virtual Machine (and the CLR, and JavaScript). It is designed to
be a general-purpose language, combining the approachability and
interactive development of a scripting language with an efficient
and robust infrastructure for multithreaded programming. Clojure
is a compiled language - it compiles directly to JVM bytecode, yet
remains completely dynamic. Every feature supported by Clojure is
supported at runtime. Clojure provides easy access to the Java
frameworks, with optional type hints and type inference, to ensure
that calls to Java can avoid reflection.

Clojure is a dialect of Lisp, and shares with Lisp the code-as-data
philosophy and a powerful macro system. Clojure is predominantly
a functional programming language, and features a rich set of
immutable, persistent data structures. When mutable state is needed,
Clojure offers a software transactional memory system and reactive
Agent system that ensure clean, correct, multithreaded designs.

I hope you find Clojure's combination of facilities elegant,
powerful, practical and fun to use.</content>
</entry>
<entry>
<title>Initial import of picoc-2.1 into the Packages Collection</title>
<updated>2012-04-27T04:48:44Z</updated>
<author>
<name>agc</name>
<email>agc@pkgsrc.org</email>
</author>
<published>2012-04-27T04:48:44Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=7861a3f46bda334b0e96b8f30199f48ee07f9697'/>
<id>urn:sha1:7861a3f46bda334b0e96b8f30199f48ee07f9697</id>
<content type='text'>
	PicoC is a very small C interpreter for scripting.  It was originally
	written as the script language for a UAV's on-board flight system.
	It's also very suitable for other robotic, embedded and non-embedded
	applications.

	The core C source code is around 4000 lines of code.  It's not
	intended to be a complete implementation of ISO C but it has all the
	essentials.  When compiled it only takes a few k of code space and is
	also very sparing of data space.  This means it can work well in small
	embedded devices.  It's also a fun example of how to create a very
	small language implementation while still keeping the code readable.

	picoc has been tested on x86-32, x86-64, powerpc, arm, ultrasparc,
	HP-PA and blackfin processors and is easy to port to new targets.

To show it working on the old DECUS grep program (included as one of its
tests):

	% time picoc work/picoc/tests/46_grep.c - case work/picoc/tests/46_grep.c
	File work/picoc/tests/46_grep.c:
	"lower-case are always ignored.  Blank lines never match.  The expression",

	      case '^':

	      case '$':

	      case '.':

	      case '[':

	      case ':':
	...
	0.651u 0.000s 0:00.68 95.5%     0+0k 0+0io 0pf+0w
	% wc work/picoc/tests/46_grep.c
	      557    1991   15172 work/picoc/tests/46_grep.c
	%</content>
</entry>
<entry>
<title>Import gcc-4.7.0 and lang/gcc47</title>
<updated>2012-04-16T04:27:18Z</updated>
<author>
<name>sbd</name>
<email>sbd@pkgsrc.org</email>
</author>
<published>2012-04-16T04:27:18Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=93f837424dd1f13caacdfbefc544594f48af6749'/>
<id>urn:sha1:93f837424dd1f13caacdfbefc544594f48af6749</id>
<content type='text'>
GCC 4.7.0 is a major release, containing substantial new
functionality not available in GCC 4.6.x or previous GCC releases.

GCC 4.7 features support for software transactional memory on
selected architectures.  The C++ compiler supports a bigger
subset of the new ISO C++11 standard such as support for atomics
and the C++11 memory model, non-static data member initializers,
user-defined literals, alias-declarations, delegating constructors,
explicit override and extended friend syntax.  The C compiler adds support
for more features from the new ISO C11 standard.  GCC now supports
version 3.1 of the OpenMP specification for C, C++ and Fortran.

The link-time optimization (LTO) framework has seen improvements
with regards to scalability, stability and resource needs.  Inlining
and interprocedural constant propagation have been improved.

GCC 4.7 now supports various new GNU extensions to the DWARF debugging
information format, like entry value and call site information, a typed
DWARF stack and a more compact macro representation.

Extending the widest support for hardware architectures in the
industry, GCC 4.7 gains support for Adapteva's Epiphany processor,
National Semiconductor's CR16, and TI's C6X as well as Tilera's
TILE-Gx and TILEPro families of processors.  The x86
family support has been extended by the Intel Haswell and AMD Piledriver
architectures.  ARM has gained support for the Cortex-A7 family.

See

  http://gcc.gnu.org/gcc-4.7/changes.html

for more information about changes in GCC 4.7.</content>
</entry>
<entry>
<title>add vala-0.16.0, the new major branch of vala (needed for newer shotwell)</title>
<updated>2012-04-11T11:43:58Z</updated>
<author>
<name>drochner</name>
<email>drochner@pkgsrc.org</email>
</author>
<published>2012-04-11T11:43:58Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=03cd7c8e665bb3c9e5ce1b4e3c27fec18526f35e'/>
<id>urn:sha1:03cd7c8e665bb3c9e5ce1b4e3c27fec18526f35e</id>
<content type='text'>
</content>
</entry>
<entry>
<title>Importing ruby-coffee-script package version 2.2.0.</title>
<updated>2012-03-04T16:14:42Z</updated>
<author>
<name>taca</name>
<email>taca@pkgsrc.org</email>
</author>
<published>2012-03-04T16:14:42Z</published>
<link rel='alternate' type='text/html' href='https://git.osdyson.ru/mirror/pkgsrc/commit/?id=a6f8d9eb90a2431901985d27578ac3592166a635'/>
<id>urn:sha1:a6f8d9eb90a2431901985d27578ac3592166a635</id>
<content type='text'>
Ruby CoffeeScript is a bridge to the JS CoffeeScript compiler.</content>
</entry>
</feed>
