Geek Answers Handbook

Unique features in web applications

There are many Java / Ruby / Python / PHP web application frameworks among others. I am interested in discovering, comparing and comparing features that are unique to individual frameworks.

What do you think of the frame structure useful and why it is important to know about it?

eg.

Can you limit one function per message.

Summary:

  • Stripes - Flash Area
  • Django - JSONified variables in templates
  • Symfony is a generation model. Basic administration generation.
  • Grails - Powerful ORM as GORM
  • Seaside - no relational database, just OO code
  • Sinatra - minimalism
  • Spring Web Stream - Stream and view area
+4
source share
13 answers

alt text http://www.symfony-project.org/images/symfony_logo.gif

Symfony does some completely unique things with regard to the PHP frameworks.

I assume some of these functions are used elsewhere, but I think they are unique in PHP.

+3
source

Minimalism Sinatra . You can write an entire web application in just one file. (Obviously, this is not a way for large applications, but for rapid prototyping, small sites and web services it is great to have everything in one place.)

+2
source

Grails http://www.cjsdn.net/JVM/Grails/Docs/1.1/img/grails.png

GORM. I have not yet seen another infrastructure with such a powerful ORM, but so easy to use.

+2
source

Django's built-in administrator is probably his killer function in terms of adoption. Write your db models, register them and start entering data. Adjust if necessary. It's simple enough that I use it all the time in projects other than django.

+2
source

You need to know how to write custom template tags in Django. For example, the following tag allows me to JSONify Django variables in a template.

@register.filter def jsonify(o): return mark_safe(simplejson.dumps(o))

This is useful because my site is all Javascript, so I use Django templates to create a version of the site without a script. This is mostly useful, so Google can crawl my site. For example, see the following page with Javascript turned on and off: http://www.trailbehind.com/Yosemite%20National%20Park/

Here are some other useful tags that I have:

 @register.filter def attr_name(id): return util.get_attribute(id).name @register.filter def dashes(name): return name.replace(' ', '-')

And isn't Python syntax syntax doing these short and clear?

+1
source

Primorye in Smalltalk supports refactoring and non-use programming. Based on components and without templates, you can avoid a lot of duplication.

+1
source

Primorye, without worrying about a relational database (SandstoneDB, Magma or Gemstone), allows you to write OO code instead of database code using some methods.

+1
source

Spring Web Stream - Serialized Conversations / Large Browser Support

Support for the back button and browser history is a headache with most web applications, simply because the state / page is too easy for the client to not sync with what's on the server.

SWF solves this by taking snapshots of the entire state of the conversation each time the view is viewed. Most stateful data is stored in one of the additional areas of SWF (conversation, stream, viewing) and therefore is serialized with a snapshot of the exchange.

SWF URLs do not identify a resource, such as a page or action. Instead, they define flow and conversation. Since SWF implements POST-REDIRECT-GET implicitly, every time a page is displayed, the URL contains flowExecutionId, which uniquely identifies the conversation and the serialized session snapshot. Thus, since the user uses the browser back button or history, each URL actually restores the entire state of the conversation at that point in time.

This leads to perfect reverse control of the buttons: the client state is never synchronized with the state of the conversation, and the user can freely continue to work from any previous state.

Developers can also discard or discard history (saved snapshots) when users perform certain actions. This is useful for user actions that change something in the database, since the user should not be able to return to a state that does not represent what is in the database.

The developer can limit the number of stored pictures. Since the capacity of the hard drive abounds, especially compared to memory, this is a pretty neat solution.

However, one of the main limitations is that any attribute located in the talk, stream, or presentation area must be Serializable.

+1
source

Spring Web Stream - Stream and view pane

Most web applications are content for using servlet-defined request, session, and context areas. However, most of the status data used in the web application does not quite fit into any of these areas. As a rule, such data lasts longer than one request, but shorter than the session. The session area is usually used in this case. This forces the developer to significantly perform manual memory management in order to put things in the session area, and then explicitly delete them when they are no longer needed for this part of the application. This can be frustrating, as there are usually several places where attributes should be removed, as there are often several actions that the user can invoke to get them out of a use case where attributes are needed.

In large or growing applications, attribute clearing code is becoming a necessary and pervasive mess throughout the code. Forgetting to clear attributes or clear error errors, you can enter errors.

SWF solves this by providing additional areas that better match the application attribute life cycle.

SWF introduces the concepts of flows, which are reusable modular groupings of behavior, presented as a state machine, consisting of states and transitions between them. The stream may include action states for invoking server-side behavior, presentation states for displaying pages to the user, and others. Threads often represent use cases. Attributes with stream coverage are stored throughout the stream and are automatically cleared when the stream ends. This results in attributes that are stored only for the duration of use, where they are needed.

ViewStates inside the stream renders the view to the user. Transitions from viewState can move to another state or can remain in the same view, re-displaying the view (with or without AJAX) after performing some actions. Attributes in viewScope are retained while the control remains in viewState. ViewScoped attributes store browser updates and are useful for data that is relevant only to the visualization, such as data that is used in AJAX requests, or for flags that somehow affect markup. When a transition is called that leaves the viewState, the viewScoped attributes are cleared.

Thus, additional areas of SWF are better suited for the application attribute life cycle, and using these additional areas eliminates the need to manually manage your attributes, which reduces the number of authorizing attribute attributes throughout the application and the potential for errors.

+1
source

CakePHP Logo

Notable CakePHP Features:

  • bake tool to automatically create models and controllers from your database.
  • zero-config - you just need to set up your database connection and you're good to go
  • scaffolding - you don’t even need to create your own views, the cake will generate them for you
  • many helpers - AJAX, JavaScript, HTML, forms, pagination, XML, RSS, you name it
  • Activerecord
  • SimpleTest for unit testing
  • data verification - easy to use but powerful
  • data processing - worry less about code entry
  • router - allows you to redirect your "custom" URLs to specific controllers / actions.

Summary: many people think Cake for PHP is the same as Rails for Ruby.

+1
source

Hmm ... I've been a PHP developer for about 15 years. Take a look at Rails (Ruby on Rails). It has some unique functions, such as database migration, the implementation of interfaces differs from languages ​​such as Java, PHP and others, configuration files are not like ini files (you can write code).

Hope this helps.

0
source

Zend framework

Zend Framework has the following notable features:

  • Pick and choose what you use. ZF is a collection of light, loosely coupled components.
  • Integration with Google , Amazon , Yahoo! , Flickr , and several other APIs
  • Easy to use XML / RPC, SOAP and REST server
  • Integration with Adobe AIR and Flex
  • Zend_CodeGenerator
  • Integrated DB, LDAP, and OpenID Authentication
  • Excellent integration with Dojo and jQuery
  • Suitable for enterprise applications (FOX, IBM, Right Media)
  • Very Active Community (#zftalk on irc.freenode.net)
  • does not create your model. (It's good).
0
source

Icefaces has a powerful scalable ajax push framework

0
source

More articles:


All Articles