old news

Development moves forward with ferite to improve speed within the engine. Work has been done to improve function calling, array access and reduce the internal structures to be much tighter and closer knit.

Happy New Year!

The website has been quiet due to work being done on ferite and webframework.

webframework is ferite's answer to web application development and you can view the documentation at webframework.ferite.org. Its development has been moving along at a good place and with its use within a few commercial applications enforcing its maturity.

ferite is moving along at a bug fixing rate with various changes under the hood making it a much better engine. There are plans to make a few more internal changes before 1.1.0 is released.

Happy New Year! If you fancy having a play with 1.1.0 and don't want to get your hands dirty with CVS, you can check out some distribution packages here.

Ferite 1.0.2 has now been released. This is a recommended update for ferite due to a number of significant memory issues having been fixed.

- Fix for a threading issue that caused the engine to crash with a memory issue. - Fix for rmi and a lack of parsing of arguments within function calls. - Fix for rmi that caused the starvation of network sockets within the server environment. The new fix forces the GC to be run when in blocking listen mode and also forces the shutdown of network sockets. - Fix for array code that would cause objects to have an inflated refcount and cause scripts to not deleted objects within the GC - Fix for refcounting issues within the assignment of objects - Fix for building on CYGWIN: required -no-undefined on the libraries and a missing header in aphex_thread.c - Fix for class/namespace modifies on a class/namesapce that already exists

Development work still continues with the unstable branch of ferite. It has the addition of directives in a nice and extensible manner, various language clean ups and fixes. This is likely to be released soon. There is significant work on the next generation compiler allowing for compile caching, multiple threaded building in parallel, code optimisation and validation, and all in about the same sort of time as the current compiler. There has also been significant work made on the webframework system - ferite's answer to the various web application platforms about. We are certain you will enjoy it. Look forward to a release and some tutorials by the end of the year!

There is a good article here about ferite - go check it out!

The initial version of the developer section of this site is alive. You can read it here. It covers the future both the language, the underlying technology and the marketting that needs to be done.

There is a new branch in town: FERITE_1_0_BRANCH.

With work starting on the 1.1.x series of ferite, it has been necessary to setup a cvs branch to cover bug fixing with ferite 1.0.x. The first release of ferite 1.0.1 will include a fix for miniferite.c, and a major fix to allow the compliation of ferite on Windows using CYGWIN. To track the bug fix branch you need to use:

cvs -z3 checkout -r FERITE_1_0_BRANCH ferite

To track the development branch of ferite you just need to checkout/update cvs as normal.

We are please to annouce the final release of ferite 1.0 and the start of work on ferite 1.1. Please make your way over to the downloads page to grab the new version.

1.1 will be bringing with it a number of nice changes to ferite. The one that is currently getting people excited is class directives. The directives allow you to define static functions to be called when building a class to provide a much more flexible guidlines to ferite. Combined with eval and you can have all sorts of fun. For example:

class modifies Obj { static function reader( string name ) { eval( " class modifies ${Class.name(self)} { function get$name() { return .$name; } }" ); } } class Example { private number X = 10; private string foo = "hi"; reader X; reader foo; }

This code causes a reader function to be created for the variables X and foo.

ctr: I am current sat in Sweden having had a long meeting yesterday chatting about the future of ferite. The result ? There is now a clear plan on how to introduce international character sets to ferites core. The main improvements of the planned compiler and virtual machine that will provide the basis for ferite 1.5 and ferite 2.0. A clear plan on how to get the documentation for ferite even futher along the road than it currently is, and a set of killer applications and services that will be developed in ferite, using webframework, to pull people towards ferite and its use. The finer details are currently sat on a pad of paper but I shall type up the notes and provide them to you very soon.

I forgot to promote the ferite shop before, but you can buy trendy clothing and mechandise that sports the cool ferite logo. There is no profit made by the team at ferite, it is just there to look cool and promote everything ferite.

Today marks the release of 12 modules for ferite. They cover various programming tasks and wrap well established libraries to increase the reach of ferite. They are:

• aspell interface to allow spell checking from scripts.
• crypt module that wraps libmcrypt to provide encryption and decryption of strings.
• curl wrapper to provide web protocol access.
• A curses interface.
• A database module to provide a database independant mechanism for database access.
• embfer module that allows you to embed ferite within tags and have it converted into text.
• gettext module to allow for translatable programs.
• A wrapper around imlib2 allowing the generation of images within ferite scrips.
• A serial module to interact with serial ports and devices on them.
• A fast templating module.
• An xslt module that allows you to apply xsl transforms to the trees created by the XML.TreeParser supplied with ferite.
• A zip module allowing the inspection of zip files.

To grab these modules please check the downloads page.

Coming soon! apache module, opengl module, email (imap) module!

Various people have highlighted the compile issues under gcc 4.0, specifically with the thread and xml modules. You can find the latest release on the downloads page.

Today marks the turn of a new era. ferite has reached the grand number of 1.0. There are numerous updates and fixes:

• Many bug fixes and performance enchancements.
• Rewritten manual, embedding guide, API and C API.
• Added feritedoc manual to aid its use.
• Creation of a 'date' module that contains time specific classes and functions.
• "" + void evaluates to "" rather than "(void)"
• Major structural changes to make method calls from native code easier.
• Static constructors and destructors on classes
• Constructors are now called 'constructor' not the name of the class
• Ability to specify a hash key for an object by overriding the hash() function
• Implementation of closures within ferite:

      number z = 10;
      object o = closure( x, y ) {
          Console.println( x );
          Console.println( y );
          Console.println( z );
      };
      o.invoke( 8, 9 );
      

  The above code captures the 'z' variable, and uses the passed in variables. Please see the manual.
• Implemented passed in blocks to functions allowing for a new dynamic method of programming. For example iterators, the array module now provides an each() method that can be used like so:

      Array.each( [ 1, 2, 3 ] ) using ( value ) {
          Console.println( value );
      };
      

  A block passed in using the 'using' keyword is a closure.
• Renamed getArgs() to arguments()
• Removed regular expressions from the language and moved them into a more ferite esque module called "regexp"
• Added ability to execute a function on an expression: (new A()).someFunction(), it is just necessary to bracket the expression.
• Added the ability to do call by reference on variables:

      function f( number &b, number a ) {
          b = 10;
          a = 10;
      }
      
      number b = 1, a = 1;
      f( b, a );
      

  b is now 10 because the variable reference was passed into f
• Added protocols to ferite allowing classes to conform to a given protocol e.g.

      protocol X {
          function getX();
          function setX( string v );
      }
      
      class A implements X {
          function getX(){ return ""; }
          function setX( string v ) { }
      }
      

  The compiler will ensure that the class does conform or wont complete compliation. It is also possible to use, on any object, the function 'conformsToProtocol' to check if the object is valid for ones purpose.
• Sliced arrays now work correctly (there was a foolish bug before)
• Added private, protected and public to the ferite compiler and engine. You can now have access control on your functions.
• Implemented abstract classes and final classes to contol who can inherit from your creations.
• Added the ability to define keys within an associated in-line script:

  array a = [ 'Key1' => value, 'Key2' => 'value2' ];

• Fixed the locating of overloaded methods when they have different parameters types. (ferite woulnd't be able to find various methods)
• Major work on the XML module to provide TreeParser and XML.Element to allow the inspection and rebuilding of the xml trees.
• Various new array and string routines
• The compiler allows you to embed block comments within each other, /* /* */ */ making the comment system more sane.
• Variable declared within a for loop (especially void variables) will be dealt with correctly (reset and not crash)
• You no longer can assign to null and nowt
• New feritedoc which is now usable and very fast, which provides much nicer documentation including an offline search mechanism. It also provides a central mechanism for updating documentation to the system documentation. (feritedoc --regenerate)
• ".feh" is now a valid script extension
• Made libxml2 a requirement for ferite.
• Builder now provides (for feritedoc) a modulename.xml that details all of the files that it used to create the native code for a module; thus making it easy for feritedoc to find what files it has to scan to get the documentation correct.
• Reworked the install paths to be more sane
• Split the originally huge sys module into several smaller ones: date, network, posix, unix, sys, filesystem, stream. This makes the module system much cleaner and also provides the stream module to make extending stream objects easier.
• A test-suite to provide unit based testing, and a set of tests.
• A fix for iferr blocks that don't have a else block
• The module subsystem can now cope with relative paths.
• The rmi (Remote Method Invocation) module now works (it showed some critical bugs with threading and the garbage collector). The internal threading system along with the thread module are much better behaved. It also reuses existing connections and doesnt eat resources.
• The addition of farm to the distribution. farm is a build system written in ferite aimed to make building code easier on one's sanity. farm takes a description constructed in XML and will build libraries, binaries and modules quicker and with less pain that autotools.
• The addition of manual-builder to the distribution. This takes the pain away from using docbook and provides a nice sane way of generating html and pdf documentation from the same source. ferite uses manual builder for the pdfs and html documentation it is provided with.
• API, C API documentation is generated on install, ferite is shipped with numerous examples, pdf and html manuals all installed locally to allow non-networked machines access to the documentation.
• Brand new logo :)

The site has been updated, the documentation has been re-written to be much more user friendly. Please take a look at the downloads page for more information on obtaining ferite and the various 3rd party modules (including modules for database, image, mail, xslt, and various other exciting modules).

So what does the future hold ?

• There is already work on the next version of the ferite compiler which will bring forward static type checking, warnings for various parts of programs that could be considered not thread safe, programmable class modifiers, and various other goodies to make development more fun. This will be merged with the current ferite runtime to provide a much nicer experience.
• There are also some experiments being conducted in to next generation VMs for ferite. There is currently much smaller type usage, increased speed and better garbage collection. Once the vm architecture has been finalised the new compiler will be merged to it. This will all be done incrementally.
• webframework is an advanced web framework that provides a state driven programming experience similar to the model-view-controller methods used with GUI programming.
• There are various modules almost here to deal with OpenGL, SOAP and various other exciting technologies.

We hope you enjoy this release of ferite, we are all very proud of it.

Within the next week or so 1.0rc1 will be released. This will initially be the code basewith the documentation following closely behind. We are aiming to get 1.0final out by the middle of July. This will include ferite with its core set of module, as well as, a whole fist of modules for doing all sorts of application development (imaging, email, templates, database access, xml and much more).

Once 1.0 has been released, work will begin on 1.1 which will push forward in terms of house keeping in: the exception system, threading, method declaration and handling, general speed improvements. We aim to have 1.1 released at the end of September 2004.

We are also investigating GUI bindings to provide developers an easy mechanism for rapidly building, prototyping and depolying interfaces that will function correctly on multiple platforms.

Having setup the mirrors, ferite.org has been renewed and transfered to a more reliable set of nameservers. The mirrors are now known as uk. se. and us.ferite.org. They are the same machines as before but have a more obvious name.

Better late than never. ferite.org has had a rocky few months due to the hosting being a bit shaky. To stop the lack of information in the future we are implementing a couple of mirrors. The first to become live is ferite.sourceforge.net. The second is the European Mirror from cention. It is ferite.centiongroup.com.

The silence is broken and code has been written. Having played with lambda calculus for so long through my PhD, I have decided to bite the bullet and add statically bound lambda constructs to ferite. The work is currently in cvs. Please see scripts/test/closure.fe.

It works nicely. I am also in the process of fixing the regular expression code that was broken when block scoped variables are in. Once these fixes are in I will do some testing and release 0.99.7.

Unfortunately, due to some technical dificulties, the site has been away. But now it is back. Most of the development on ferite has halted whilst we have a break over the summer and collect our ideas. We are not dead - just revitalising ourselves.

Work in progress has been the Ferite.framework which is a ObjectiveC framework for quickly deploying ferite into Cocoa based Mac OS X projects.

There has also been work on making all type objects which will no doubt feature in the CVS repository once it has become slightly less unstable.

The recent CVS changes have made it possible to make class items private, protected or public. This make larger projects and library access control more flexible. By default variables are private and methods are public.

It is also now possible to make classes abstract or final. And when an error is thrown and not caught a backtrace is given out making finding the errors easier.

Due to technical issues at SourceForge, anonymous CVS access is currently unavailable. The cvs browser and examples page will be down for the duration. More info can be found on the SourceForge.net site status page.

Happy New Year! What with Christmas having passed aswell as the New Year, we have a present for you. It's a new stable version of ferite. This feature is as big as before and provides even more goodies for people to play with. Go and play! The release notes are below:


• Many bug fixes and performance enhancements including speedups between 3-12 times and a couple of critical compiler fixes.
• Much more documentation, including API, C API and a developers guide
• Object methods can call the constructor of their parent class with super().
• Single line functions don't need braces around the function body, eg.

  	            
        function foo( number bar )
          return bar + 42;
      

• Added the foreach() operator.
• Added ( foo ? bar1 : bar0 ) conditionals.
• Added parameter overloading- you can now do things like:

  	        
        function foo( number bar )
  	Console.println("foo: got number " + bar);
  	
        function foo( string bar )
  	Console.println("foo: got string " + bar);
      

• Changed the way variable argument lists are accessed via script code
• Added many new functions, classes, and constants to the Sys module. In particular:
  • Syslog
  • select()
  • printf()
  • UDP sockets
  • Signal handlers
  • Full IPV6 support
  • Unix domain sockets
  • A pipe stream class
  • A string stream class
  • A host class for DNS lookups
  • Many system constants (eg. the errno and signal values), the values of which are determined at compile time
• Rewrote several String functions and added many new ones
• Added several new Array functions, including a generic array sorting routine
• Added several new Reflection functions, including better object and function runtime inspection, and the ability to trace a variable's modification.
• Feritedoc is now much faster
• Basic Remote Method Invocation framework in pure ferite
• The ability to duplicate a scripts in C code
• The XML module has been re-written in places to be more flexible
• Saner Error handling regarding multiple threads within a script

Ferite works on Linux, Solaris, Mac OS X, Cygwin and FreeBSD. Please see the download page for details on obtaining ferite. I have also modified the site menu to make navigation less complicated and confusing.

Well, as promised there is a developers guide availiable. It is currently in a state of flux and any significant updates will be mentioned here. You can access it the same formats as the normal manual by clicking on the menu items on the left. Enjoy.

The documentation had been updated on this site to include the latest cvs documentation for the manual, the module api and the C api for developers. This should make developing ferite easier. Aswell as online versions there are tarballs that can be downloaded. The next piece of documentation on its way is the guide for developers wishing to do clever things with ferite. Enjoy.

After some down time and various people having breaks from coding, development has started again, the website is back and things are starting to gain more momentum. Recently there has been a huge commit by Alex Holden on the Sys module providing some posix'y good ness, and work on better variable handling in the engine with a view of implementing block-nested-variables at somepoint soon. Be patient as 0.99.6 will be here at somepoint soon.

ferite is still alive. This seems like deja-vu. There hasn't been that many news items of worthy note recently. The main changes between 0.99.5 and the current source tree is numerous bug fixes and clean ups aswell as vast speed improvements. The ackermann benchmarks now run three times faster than before. There are also some syntax cleanups, additions aswell as some documentation for developers.

ferite 0.99.5 has now been released. It's hot, its great, go download and play with it now. You should be impressed. We are, it's definatly been work the last 6 months hard work. Here are the release notes:

• FreeBSD, Darwin, OpenBSD and Solaris fixes
• Support for Cygwin
• ferite.m4 for easy ferite install checking
• Cross platform library for system interaction [aphex], Provides consistant file, directory and threading interface
• man pages for both ferite and builder
• Full api documentation
• function renaming and deletion in classes
• Complete re-write of the array subsystem
• Large amounts of module work
  • Complete re-write of the module system
  • Re-write of builder to reflect changes
  • Much more flexible load unload system
• Syntax clean ups
  • Slice operator - allows the selection of ranges out of an array or string
  • Removed '->'
  • uses now only accepts a quoted string. Including a new contruct c///, this allows for capture strings to be placed in the variables mentioned in the comma separated list on the right hand side.
  • Better regular expression detection and processing
  • New 'atomic' keyword for threadin - provides locking for functions and variables at script level.
  • Code at the end of a module is now executed when loaded in
  • eval() modifies the script it runs in
  • include() can be used to load up another script at run time
  • Arrays can be created in scripts using [ value, ... ] syntax
  • isa operator to check a variables type
  • instanceof operator to see if a variable is an instance of a class or parent class.
  • Ability to embed expressions in a string using "${expr}" syntax.
• More functionality added to the command line ferite tool
• Big clean up of the native api
  • More convinience functions
  • More macros for easy of use
  • All functions now start with ferite rather than __ferite
• generate-module - a tool to allow the easy deployment of third party modules
• feritedoc - a javadoc like tool for generating documentation in various formats, currently only text and html are outputed. [used for the api docs]
• New system module, providing a complete stream interface, test suite, serialization, and threading libraries. See the API docs for more information.
• More test scripts
• Variable accessors allowing for tracking of variable changes in native code
• Hundreds of bug fixes and clean ups

We hope you enjoy :-) Please see the download page for obtaining instructions.

ferite 0.99.5 will be released at the end of this week, cvs represents the current state of affairs and only bug fixes will be changed. Just to let you know.

We are still alive, bug fixing and keeping things tidy. We should be have a release for you soon. Expect nice things. ferite is much more real than before, other releases look like technology demos compared to the current code base. In other words, we are all very happy with the way it has progressed!

Due to issues the site was down for a short while because of dns changing. We also changed the box the site is hosted on at the same time. Sorry for the issues.

ferite cvs is coming along very nicely with various toys being developed to make it even more powerfull than a very powerfull thing. Like a medium sized pony, or a tractor. But enough, what are these features? Multi threading - ferite can run multiple scripts within the same engine, and also run multiple threads per script. There is a thread class, atomic variables and methods [these give the ability to have critical sections, and also have variables where all operations done on them are atomic!]. Writing a threaded script is ever so simple - simply inherit from the Thread class and implement a run() method. See here for the example. Ferite can also store binary data in strings - which makes processing of data easier. There is a new range operator allowing for manipulation, and the "->" operator has been removed. The underlying API has been cleaned up, bugs fixed and all in all ferite is moving along nicely. There is a stream framework in the pipeline and the modules are being cleaned up. 0.99.5 is going to be a very big release and quite exciting :).

I just want to thank ntropy and Stephan Engström for their continual help.

Work is going along, but a bit slow at the minute due to real world commitments - things should pick up in week or two. On another note, if you want to link to ferite.org you can use the image on the left, and use the code:

<a href="http://www.ferite.org"><img border=0 src="http://images.ferite.org/ferite-dot-org.gif" alt="ferite language"></a>

Work is still happening quietly in the background, there is new faster array code in cvs - which reduces memory overhead aswell, there is a new module system that is about 1000% more flexible and uses less memory. Things are progressing nicely and I am sure there will be a release at somepoint in the future - sooner rather than later.

You can now get ferite using apt. To play do: apt-get install ferite. Have fun :)

This has a number of features and in summary:

"Cleaner and better native side API, builder enhancements, new library loader system, module changes, new: ipc, reflection, speech, improved: file, string and system modules. Enhancements to the language including array initialisers, switch statement, the ability to assign initial values to global, class and namespace variables. ANSI C clean ups, and a number of critical fixes within the compiler and the executor. There are also hundreds of little fixes making this a much cleaner and stable release than before."

This release is a highly recommend release - it provides a much cleaner system and should be alot more usable. Go fetch it off the downloads page.

Happy Belated New Year - things have been happening and happening fast. Development has slowed to bug fixing and clean ups to make cvs more releasable. This should be occuring soon (later than I wanted but hey thats life). 0.99.4 will be a much more solid release than before with more API, greater stability, more goodies, less dependancy hell. It also will allow a sync in api on the native side of things allowing applications to be using either cvs or release ferite and not worry :).

If you find any serious bugs in cvs please let us know.

Thanks, Chris Ross.

I have added two syntax hi-light files for you to download. The first is for vim it can be found here and was created by ymer. The second is for Kate and it can be found here, and was create by myself.

Development has been progressing nicely with bigger and better string, file, reflection and system modules, compiler fixes, source clean ups, more flexibility, memory usage and tweaking abilities, switch statement, plus a whole host of other goodies. Please check out the ChangeLog. We are now preparing to go for the 0.99.4 release of ferite.

For those of you wanting to use ferite in your application please see the document that is on the developer's page - this should give you a good base point to start.

I have updated the tool - this fixes some issues with the .fec file being modified and builder rebuilding it. You can grab a copy here here. Please read the README file in the package.

I have create a tool that will take a .fec file and generate a tarball so that it can be distributed and installed on other systems. It's new and probably breaks all over the place, but you can grab a copy here here. Please read the README file in the package.

This has a number of features and in summary:

"More documentation, variable argument lists, autoload methods in classes, runtime script inclusion,ÛÞ