A Look Into Other Programming Languages Frameworks

There are other programming languages than PHP, Ruby, ASP and Java too. Some of them are new while others are quite old and mature. Yesterday, someone pointed me on Cappuccino and to tell you the truth, a whole new world was just revealed in front of my eyes. So, i decided it would be good to write something about “other” frameworks out there. I Googled, Yahoo’ed and Binged and here is what i have found.

The SproutCore Framework (HTML5, Javascript)

The purpose of the SproutCore 1.0 project is to create the first official stable and generally usable release of the SproutCore platform.  This means an average-level developer with no prior experience with SproutCore should be able to easily create and deploy a basic Cloud Application that runs on all modern browser platforms. SproutCore 1.0 Beta is available as a Ruby gem from Github.  This gem is updated periodically whenever major new changes are published to the Beta.

In other words, SproutCore is an HTML5 Application framework. The framework is on a beta stage but the stable release will be released soon according to the SproutCore site. The platform consists of a JavaScript framework, build tools, documentation, sample code, and a website. When complete, a developer with no prior experience building SproutCore applications must be able to visit the website, install the software, build and deploy a basic Cloud Application, including a data model, server interaction, bound views and controllers, without needing any personal assistance from the developers of the software.

The getting started guide and the Hello World tutorial are the places to really get you started. I suggest you read the comments on each example to bypass some common problems and misunderstandings. There are also some screencasts to help you go deeper.

Django (Python)

Developed four years ago by a fast-moving online-news operation, Django was designed to handle two challenges: the intensive deadlines of a newsroom and the stringent requirements of the experienced Web developers who wrote it. It lets you build high-performing, elegant Web applications quickly.
Django is available open-source under the BSD license. It requires Python version 2.3 or higher, but it has no dependencies on other Python libraries.Development of Django is supported by an independent foundation established as a 501(c)(3) non-profit. A strong and stable framework that lets you choose your URL scheme, having it’s own templating system and automated routines that will make your code reusable and manageable.

Here is a good point to start your adventures with Django.

Catalyst (Perl)

Catalyst is an elegant web application framework, extremely flexible yet extremely simple. It’s similar to Ruby on Rails, Spring (Java), and Maypole, upon which it was originally based. Its most important design philosphy is to provide easy access to all the tools you need to develop web applications, with few restrictions on how you need to use these tools. However, this does mean that it is always possible to do things in a different way.
Catalyst is designed to make it easy to manage the various tasks you need to do to run an application on the web, either by doing them itself, or by letting you “plug in” existing Perl modules that do what you need. It is extremely flexible in terms of what it allows you to do, and very fast. It has a very large number of “plugins” that interact with existing Perl modules so that you can easily use them from within your application. Catalyst comes with its own built-in server for testing, supports many database schemes and automated tests and logs.

Extensive documentation and manuals can be found here and the Advent Calendar is a must read resource.

Gantry (Perl)

Gantry is a Perl- powered Web application framework. Started as a proprietary toolkit, Gantry has evolved through three major revisions. In 2005, Gantry was released as open source software under the same license as Perl itself, and maintenance and enhancement continue to this day. Like many other frameworks, Gantry implements the classic Model-View-Controller (MVC) pattern. However, Gantry allows you to use as much as or as little of the pattern as you’d like. If you code in Perl and want to both jumpstart and simplify your next Web application, Gantry can give you a boost.

Gantry is a very good documented framework. You can read a starting tutorial on how to create an address book, read the full documentation for all of Gantry’s modules and watch videos of how to use Gantry.

Cappuccino (Objective – J)

Cappuccino is an open source application framework for developing applications that look and feel like the desktop software users are familiar with.
Cappuccino is built on top of standard web technologies like JavaScript, and it implements most of the familiar APIs from GNUstep and Apple’s Cocoa frameworks. When you program in Cappuccino, you don’t need to concern yourself with the complexities of traditional web technologies like HTML, CSS, or even the DOM. The unpleasantries of building complex cross browser applications are abstracted away for you.
Cappuccino was implemented using a new programming language called Objective-J, which is modelled after Objective-C and built entirely on top of JavaScript. Programs written in Objective-J are interpreted in the client, so no compilation or plugins are required. Objective-J is released alongside Cappuccino in this project and under the LGPL.

Cappuccino doesn’t ask you to write HTML CSS or to interact with DOM. The only thing you have to do is learn Objective-J. Yet, it is not intented to create web sites. Using the right tool for the right job is a clever way to get your self to the next level and Cappuccino is the right tool for applications that deliver the desktop experience to the end user.

The first major Cappuccino application, 280 Slides is one of the most advanced applications on the web today. It makes heavy use of some of the most advanced features of Cappuccino, including the built-in document architecture, object copy and paste, undo and redo, and smooth interactive graphics.

Tutorials about Cappuccino can be found here and there is also an API documentation available.

Cairngorm (Flex)

Cairngorm is the lightweight micro-architecture for Rich Internet Applications built in Flex or AIR. A collaboration of recognized design patterns, Cairngorm exemplifies and encourages best-practices for RIA development advocated by Adobe Consulting, encourages best-practice leverage of the underlying Flex framework, while making it easier for medium to large teams of software engineers deliver medium to large scale, mission-critical Rich Internet Applications.

The community documentation is a great place to start with Cairngorm.

PureMVC (Actionscript 3 …)

PureMVC is a lightweight framework for creating applications based upon the classic Model, View and Controller concept.
Based upon proven design patterns, this free, open source framework which was originally implemented in the ActionScript 3 language for use with Adobe Flex, Flash and AIR, is now being ported to all major development platforms.Two versions of the framework are supported with reference implementations; Standard and MultiCore.
In the standard implementation, the Model, View and Controller application tiers are represented by three Singletons (a class where only one instance may be created).
The MVC Singletons maintain named caches of Proxies, Mediators and Commands, respectively. The Façade, also a Singleton, provides a single interface for communications throughout the application. These four Singletons are referred to as the Core Actors.
In the MultiCore implementation PureMVC supports modular programming, allowing the use of independent program modules each with their own independent PureMVC ‘Core’. A Core is a set of the four main actors used in the Standard framework (Model, View, Controller and Facade) This version of the framework uses Multitons instead of Singletons. Rather than storing a single instance of the class, a Multiton stores a map of instances. Each Core is referenced by an associated Multiton Key.

PureMVC has been ported to other languages too. There are ports to AS2, C#, Coldfusion, haXe, Java, Javascript, PHP and Python. An extensive documentation can be found here.

Lift (Scala)

Lift is an expressive and elegant framework for writing web applications. Lift stresses the importance of security, maintainability, scalability and performance, while allowing for high levels of developer productivity. Lift is open source software licensed under an Apache 2.0 license.
Lift borrows from the best of existing frameworks, providing Seaside’s highly granular sessions and security, Rails fast flash-to-bang, Django’s “more than just CRUD” is included and Wicket’s designer-friendly templating style and because Lift applications are written in Scala, an elegant new JVM language, you can still use your favorite Java libraries and deploy to your favorite Servlet Container. Use the code you’ve already written and deploy to the container you’ve already configured!

The documentation is there to provide documented API and a getting started tutorial will get you into it right away.

Echo (Javascript, Java)

Echo is an open-source framework for developing rich web applications. From the developer’s perspective, Echo behaves as a user interface toolkit–like Swing or Eclipse SWT. AJAX technology is employed to deliver a user experience to web clients that approaches that of desktop-based applications. Echo applications can be created entirely in server-side Java code using a component-oriented and event-driven API (applies to Echo2 and Echo3) or as client-side applications written in JavaScript (applies to Echo3 only).
There are two types of web applications which may be developed with Echo3: applications whose code is executed on the client, and applications whose code is executed on the server.

Client-side Echo applications are written in JavaScript, which is executed directly by the client browser. Such applications will use XML, JSON, or some other protocol over HTTP to communicate back to the server. Because all user-interface related code is executed only on the client, the applications will only be delayed by the server when they need to query a server-side data store (database, web services, etc).

Server-side Echo applications are written in Java (other languages may be supported in the future). A server-side Echo application communicates with a special “thin client” Echo application that is provided by the framework itself. This thin client application synchronizes its component state to that of the server-side application, and sends any user-generated events back to the server. A server-side Echo application may communicate more directly with its datastore, calling into a Java middle tier directly and/or using such protocols as JDBC, RMI, LDAP, or XML-over-HTTP to remote servers (rather than only to the host server).

Echo2 Tutorial

Grails (Groovy)

Grails is a full stack framework and attempts to solve as many pieces of the web development puzzle through the core technology and it’s associated plug-ins. Included out the box are things like:

• 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

Grails development needs nothing more than a text editor, but of course there are many sophisticated tools available to improve productivity, including syntax highlighting, refactorings and grails command execution.

The documentation is a good place to start with Grails. You can find tutorials, books, plugins and tools that will really boost your learning to the maximum.

Helma (Server Side Javascript)

Helma is a server-side Javascript environment and web application framework for fast and efficient scripting and serving of your websites and Internet applications.
Helma is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.
Helma pioneered the simple and codeless mapping of application objects to database tables. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects.
Helma can serve multiple independent applications, each accessible through a different mountpoint, using Javascript environments running in their own global scope, and configurable to use separate code repositories.
A Helma default installation, for example, is serving the applications “manage” and “welcome” and makes them accessible through the http://helma.serverjs.org/manage/ and http://helma.serverjs.org/ URLs respectively. The list of active applications is defined by the file ./apps.properties in Helma’s home directory.

Documentation

Tcl Web Application Framework (Tcl)

The Tcl Web Application Framework helps simplify writing Web applications in the Tool Command Language (Tcl). It provides the features that form the basis for writing an application, such as sessions, users, privilege separation, and an abstract database interface. It is currently under development, but stable for production use.

It is written in such a way that applications can integrate into the framework without having to modify the framework itself, making upgrading the framework without breaking the application possible.

FarCry Core (Coldfusion)

FarCry is an open source, web framework that encourages rapid application development on the ColdFusion platform. FarCry is a set of core components that takes care of a lot of the programming work that goes into building web applications and other database-driven websites so you don’t have to. Those things that must be done for nearly every web site are built-in, so you can ignore them and focus on what makes each site unique.
FarCry can be used to manage access to the database and the evolution of the underlying schema itself with little or no programming. There are several supported databases, including My SQL, Postgres, Microsoft SQL Server and Oracle. No SQL is needed.

FarCry Documentation

Orbit (Lua)

Orbit is an MVC web framework for Lua. The design is inspired by lightweight Ruby frameworks such as Camping. It completely abandons the CGILua model of “scripts” in favor of applications, where each Orbit application can fit in a single file, but you can split it into multiple files if you want. All Orbit applications follow the WSAPI protocol, so they currently work with Xavante, CGI and Fastcgi. It includes a launcher that makes it easy to launch a Xavante instance for development.

Here is a tutorial to get you started with Orbit.

Update:

We love feedback. We also like it when people critisize on our articles. We should first apologize because we left out some great frameworks like Compojure and SeaSide. We add them today though.

SeaSide (Smalltalk)

Seaside provides a layered set of abstractions over HTTP and HTML that let you build highly interactive web applications quickly, reusably and maintainably. It is based on Smalltalk, a proven and robust language that is implemented by different vendors. Seaside includes:

• Programmatic HTML generation. A lot of markup is boilerplate: the same patterns of lists, links, forms and tables show up on page after page. Seaside has a rich API for generating HTML that lets you abstract these patterns into convenient methods rather than pasting the same sequence of tags into templates every time.
• Callback-based request handling. Why should you have to come up with a unique name for every link and form input on your page, only to extract them from the URL and request fields later? Seaside automates this process by letting you associate blocks, not names, with inputs and links, so you can think about objects and methods instead of ids and strings.
• Embedded components. Stop thinking a whole page at a time; Seaside lets you build your UI as a tree of individual, stateful component objects, each encapsulating a small part of a page. Often, these can be used over and over again, within and between applications – nearly every application, for example, needs a way to present a batched list of search results, or a table with sortable columns, and Seaside includes components for these out the box.
• Modal session management. What if you could express a complex, multi-page workflow in a single method? Unlike servlet models which require a separate handler for each page or request, Seaside models an entire user session as a continuous piece of code, with natural, linear control flow. In Seaside, components can call and return to each other like subroutines; string a few of those calls together in a method, just as if you were using console I/O or opening modal dialog boxes, and you have a workflow. And yes, the back button will still work.

Examples and Documentation for SeaSide.

Compojure (Clojure)

Compojure is an open source web framework for the Clojure programming language. Clojure is a dynamic programming language that targets the Java Virtual Machine. 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.

Compojure emphasizes a thin I/O layer and a functional approach to web development. In Compojure, HTTP requests and HTTP responses are represented by Clojure maps. A *handler* is a function that takes a request map as an argument, and returns a response map.

The Compojure wiki is a great place to start. You can read a tutorial here too.

Popularity: 3%

No related posts.