quick example:

      uses "console";
      Console.println( "Hello World" );

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.