Solucom - Dreamsoft - APP - Veille has no followers yet. Be the first one to follow.
At FOWA London 2009 Bruce Lawson gave an introduction to HTML 5 and how it might be used in the future.
The HTML 5 spec was originally called “Web Applications 1.0″. Most of the attention has been on the new markup elements, but in his talk he takes a further look at the applications side of the spec, covering:
Dynamic images and graphs with canvas
Eliminating much forms validation with webforms 2.0
Local storage automagically saving your data
Geolocation
Building toolbars and menus.
Editor’s Note: We’ll be covering “How HTML 5 is Going to Completely Change your Web App” at The Future of Web Apps in Miami.
You can jump straight to the video, view the slides, read the transcript (thanks @joeloverton for doing this!), or check out the resources he demos in the talk:
Eye-candy canvas
canvas first-person shooter
canvas first-person gifter
the excanvas library to port canvas to Internet Explorer
Filament Group’s jQuerty plugin using canvas for graphing data tables
Raphaël JavaScript Library to make SVG that also works in Internet Explorer
SVG Web is a JavaScript library which provides SVG support on Internet Explorer (Alpha code: not ready for production)
My HTML 5 forms demo, including range, date, placeholder, regex validation (Try in Opera and Chrome)
modernizr – A small HTML 5 capability detection library
HTML 5demos.com – Remy Sharp’s demos of geolocation, offline storage and web database and many others
Video demos
Other useful resources:
SVG vs. Canvas on Trivial Drawing Application: a comparison of canvas and SVG
HTML 5 Authors spec
A video of Dean Edwards demoing his unreleased JavaScript library that detects and plugs the holes in current browsers’ HTML 5 support
There are some great beginner canvast tutorials on the Opera Developer:
HTML 5 canvas – the basics
Creating an HTML 5 canvas painting application
Creating pseudo 3D games with HTML 5 canvas and raycasting
Creating pseudo 3D games with HTML 5 canvas and raycasting: Part 2
The video
Full transcription available at joeloverton.com/html5. We’d like to say a HUGE thank you to @joeloverton for doing this transcription!
The slides
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/TRolKLMg7fo/
Pour répondre à la demande de la commission européenne, Windows 7 laissera le choix du navigateur Internet. Une page s’affichera permettant aux utilisateurs de choisir entre Internet Explorer, Firefox, Safari, Google Chrome et Opéra (ce qui ne devrait pas faciliter la tâche de ceux qui n’y connaissent pas grand chose).
Pour ma part, et comme nous sommes plusieurs à utiliser l’ordinateur et Firefox, j’ai adopté Chrome pour ne plus avoir besoin de me délogguer de mes sites favoris (Comment cela, tout le monde s’en fiche ?).
2 précédentes notes web 2.0
20/02/200906/04/2009
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/MI0UBRU-UuA/
J’ai reçu il y a quelques semaines le livre Spring par l’exemple de Gary Mak, traduit en français et publié chez Pearson. La traduction en français est d’excellente qualité. Bravo à Hervé Soulard pour la traduction et à Eric Hébert pour la relecture technique.
Les quelques 510 pages couvrent le framework Spring en axant l’ouvrage sur la pratique. Chaque thème est construit autour du tryptique « Problème,Réponse,Exemple ». Après avoir découvert la configuration des Beans, puis les fonctions élaborées du conteneur, les choses vraiment intéressantes commencent au chapitre sur les proxy dynamiques et l’AOP.
Le sommaire du livre:
1. Inversion de contrôle et conteneurs
2. Introduction au framework Spring
3. Configuration des beans
4. Fonctions élaborées du conteneur Spring IoC
5. Proxy dynamique et Spring AOP classique
6. Spring 2.x AOP et prise en charge d’AspectJ
7. Prise en charge de JDBC
8. Gestion des transactions
9. Prise en charge de l’ORM
10. Framework Spring MVC
11. Intégration avec d’autres frameworks web
12. Prise en charge des tests
Le chapitre sur la prise en charge de JDBC, suivi du chapitre sur les Transactions, avant d’attaquer la partie ORM, permet d’apprendre les bases d’une bonne utilisation de Spring 2.5 essentiellement. Le Framework MVC est survolé dans les derniers chapitres, l’intégration avec d’autres frameworks traite de Struts et de JSF. La prise en charge des tests permet enfin de terminer par quelques cas.
Je trouve le livre plutôt bien fait. Pour un débutant sur Spring, c’est un bon départ. Il permet d’apprendre à utiliser Spring non pas en proposant de long discours, mais vraiment en vous mettant derrière les fourneaux. En tant que sénior, je reste un peu sur ma faim, mais j’ai appris quelques astuces supplémentaires.
Le livre est proposé à 39.90 EUR, le site de Pearson vous offre 2 chapitres gratuitement.
J’ai aussi parlé avec Julien Dubois de SpringSource lors de l’USI 2009, et il m’a indiqué que la nouvelle édition du livre qu’il a coécrit avec Arnaud Cogoluègnes, Thierry Templier, et Jean-Philippe Retaillé est sortie le 9 juillet dernier. Voir Amazon.fr.
En attendant je commence à lire le livre d’Antonio Goncalves sur JEE6, qui a dit que l’on ne faisait rien l’été ?
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/WybdgJndQik/
Voici enfin le dernier billet de ma visite à Jazoon 2009. Je termine le troisième jour par une présentation de Mockito par l’excellent Szczepan Faber. Il bosse à Varsovie en Pologne, c’est un ancien de ThoughWorks London, un ancien barman lorsqu’il était étudiant, et surtout ce genre de personne qui vous font passer une heure délirante en parlant d’un sujet sérieux.
Allez soyons sérieux 30 secondes…
Après une introduction, sa présentation débute par un slide avec la définition d’un Mock.
Il pose la question : qu’est-ce qu’un mock ?
Sa réponse : “C’est un substitut d’un objet réel afin de faire des tests, en simulant les interactions“.
Comme personne ne pipe mot, il appuie sur espace et une… poupée gonflable apparaît alors : “vous voyez ? un mock permet de se passer de la vraie instance d’un objet, afin de pouvoir faire des tests tranquillement avec un substitut…“.
La salle est morte de rires, je crois que tout le monde se souviendra de la définition d’un Mock.
Il continue ensuite, et puis au 4ème slide il démarre Eclipse, afin de nous montrer un peu comment marche Mockito. Hop quelques lignes, on note au passage sa maîtrise des raccourcis d’Eclipse, parfois j’ai même eu envie de passer à Eclipse et de laisser tomber IDEA IntelliJ. Mais vu que visiblement ce bonhomme n’est pas humain, ou qu’il y a un truc, je suis donc resté à intelliJ.
Le voilà qui code une classe, un mock. Mais il utilise… EasyMock. Est-ce que quelqu’un va lui dire qu’il s’est planté ? Que nenni ! C’est fait exprès…. Aaaah d’accord. Là je vais pas pouvoir continuer à bloguer cher lecteur, car le bonhomme en question a ensuite passé 32 minutes à coder, comme une bête.
J’ai tout d’abord retenu une petite astuce toute simple à reprendre dans vos tests unitaires. Utilisez les expressions “given/when/then” pour exprimer vos tests.
Cela donne par exemple :
@Test
public void shouldIncrementMyValue() throws Exception { // given // when // then }
J’ai ensuite surtout vu la différence entre easyMock et Mockito. Respect à David Gageot qui nous l’a dit il y a 6 mois. Oui Mockito est mieux qu’easyMock. Maintenant il faut que je dise pourquoi. Ca c’est le plus dur, surtout sans notes. Durant sa présentation je n’ai pas eu le temps de prendre des notes. Ce bonhomme étant trop fort avec machin-eclipse, impossible de le suivre. Ensuite, sa présentation étant vraiment bien, et sans temps morts, j’ai pas pris de notes. Voilà désolé, hop là je sens un grand cri de frustration… allez je vais chercher des bouts de codes et je reviens. Mais je vous dis, sans notes, ça va être difficile.
Regardons tout d’abord Mockito, le code ci-dessous n’est pas du bon code mais simplement quelques lignes afin de vous montrer le fonctionnement de Mockito.
import static org.mockito.Mockito.*; import java.util.LinkedList; /** * Simple Mockito test. * @author Nicolas Martignole */
public class Test { @SuppressWarnings("unchecked") public static void main(String[] args) { // Creation d'un mock LinkedList mockedList = mock(LinkedList.class); mockedList.add("Test Touilleur 1"); mockedList.clear(); // Faire autre chose // .... // Verifier que l'on a ajoute un element verify(mockedList).add("Test Touilleur 1"); // Verifier que l'on a vide la liste verify(mockedList).clear(); }
}
La différence avec EasyMock : pas de replay à effectuer. Le premier appel à un verify bascule le mock automatiquement. On voit aussi que la syntaxe est facilement lisible : “verifier que mockedList point clear a ete appelé”
Mockito est aussi très intéressant lorsqu’un événement non attendu survient. Imaginons que je m’attende à ce que ma liste “mockée” soit manipulée, que l’on effectue un deuxième ajout. J’ajoute donc une étape de vérification qui va planter puisque je n’ai pas ajouté de deuxième élément à ma liste. Regardons comment le code réagit dans ce cas précis :
import static org.mockito.Mockito.*; import java.util.LinkedList; /** * Simple Mockito test. * @author Nicolas Martignole */
public class Test { @SuppressWarnings("unchecked") public static void main(String[] args) { // Creation d'un mock LinkedList mockedList = mock(LinkedList.class); mockedList.add("Test Touilleur 1"); mockedList.clear(); // Faire autre chose // Verifier que l'on a ajoute un element verify(mockedList).add("Test Touilleur 1"); // Verifier que l'on a vide la liste verify(mockedList).clear(); // Verifier que l'on a aussi ajouter un autre element // ce qui n'est pas le cas, Mockito va donc // nous le signaler verify(mockedList).add("not added"); }
}
Voici ce que Mockito affiche lors de l’exécution :
Exception in thread "main" org.mockito.exceptions.verification.WantedButNotInvoked:
Wanted but not invoked:
linkedList.add("not added"); at Test.main(Test.java:30)
En clair : vous avez demandé à vérifier que l’on ajoute la phrase “not added” mais ce n’est pas le cas. Mockito produit des exceptions très claires lorsqu’un cas non attendu survient. Il sépare clairement aussi la définition du stub de la partie vérification, très facilement.
Je vous encourage à tester Mockito si vous utilisez easyMock, ou si les Mocks ne vous disent rien. Mockito permet de mocker des classes concrètes, certain préfèrent mettre des interfaces partout, et mocker ces interfaces. A la limite, faites ce qui vous arrange, la pratique des interfaces venant d’un livre de Martin Fowler qui disait, je crois, qu’il faut mocker des rôles, donc des interfaces.
Quelques derniers mots sur les charmes de Mockito : - possibilité d’utiliser une vérification avec un ordre : inOrder() - atLeast(x), times(x), etc. - verifyNoMoreInteractions() - enchainement de commandes: thenReturn(x).thenThrow(y) - possibilité de matcher avec des arguments comme: anyObject(), etc. - utilise hamcrest comme jMock
J’espère que nous aurons l’occasion de rencontrer Szczepan à Paris, au Paris JUG. Si vous le voyez à Devoxx 2009, croyez-moi cela vaut le coup.
Références
- Blog de Szczepan
- http://mockito.org/
- L’api de Mockito
Retrouvez l’ensemble des mes articles sur Jazoon 2009 sur cette page
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/mOqw7TLWbrA/
Apache’s .htaccess configuration files have baffled countless developers. This tutorial aims to break through this confusion by focusing on examples and thorough descriptions. Among the benefits of learning .htaccess configuration is automatic gzipping of your content, providing friendlier URLs, preventing hotlinking, improving caching, and more. First, the basics.
Introduction:
I’ve read a number of .htaccess articles online. I’ll shamelessly admit
I didn’t get beyond the front page of Google results. I was shocked when
I actually read the articles and found that none of them explained what Apache was actually
doing. They were merely a collection of popular or useful tricks or
snippets of reusable code. That is all well and good, but the classic
argument is:
“Give a man a fish and he will eat for a day. Teach a man to fish and he
will eat for a lifetime.”
- Confucius
In this article I’m going to try to not just show you examples of useful
.htaccess directives, but explain exactly what is
going on. This way, you will understand the core principles and can then extend the
examples or create new commands for your own use in whatever creative or useful ways
you can come up with.
My focus will be on Apache 2, however much of this will apply
to Apache 1.3 and I’ll try to point out any differences that I know of.
Finally, this tutorial will make the most sense if you read it in order.
I try to tie my examples together, and build off of them, in such a
way that you can try them yourself and follow along.
What is .htaccess?:
To quote Apache:
.htaccess files (or “distributed configuration files”) provide a way to make
configuration changes on a per-directory basis. A file, containing one or more
configuration directives, is placed in a particular document directory, and the
directives apply to that directory, and all subdirectories thereof.
Directives
“Directives” is the terminology that Apache uses for the commands in Apache’s
configuration files. They are normally relatively short commands, typically
key value pairs, that modify Apache’s behavior. An .htaccess file allows
developers to execute a bunch of these directives without requiring access to
Apache’s core server configuration file, often named httpd.conf. This file,
httpd.conf, is typically referred to as the “global configuration file” and I will
refer to it with that name or its short filename equivalent.
This feature is ideal for many hosting companies deploying a shared hosting
environment. The hosting company will not allow its customers to access the
global configuration file, which ultimately affects all of the customers hosted on
that server. Instead, by enabling .htaccess, they give each of their customers
the power to specify and execute their own Apache directives in their own
directories and subdirectories. Of course it’s also useful to the single
developer, as you will see.
It’s worth mentioning that anything that can be done with a .htaccess file can
be done in the httpd.conf file. However, NOT everything that can be done in
httpd.conf can be done in a .htaccess file. In fact .htaccess files must be
enabled in the httpd.conf file in order to be executed at all. Once enabled,
their power can be limited to certain “contexts” so that they may be allowed
to override some settings but not others. This gives the system administrators
more control over what they let other developers get away with in their
.htaccess files.
Enabling .htaccess:
.htaccess files are normally enabled by default. This is actually controlled
by the AllowOverride Directive in the httpd.conf file. This directive
can only be placed inside of a section. Don’t let this confuse
you. The typical httpd.conf file defines a DocumentRoot and the majority
of the file will contain Directives inside a section dealing
with that directory. This includes the AllowOverride directive.
The default value is actually “All” and thus .htaccess files are enabled by
default. An alternative value would be “None” which would mean that they are
completely disabled. There are numerous other values that limit configuration of only
certain contexts. Some are:
AuthConfig - Authorization directives such as those dealing with Basic Authentication.
FileInfo - Directives that deal with setting Headers, Error Documents, Cookies, URL Rewriting, and more.
Indexes - Default directory listing customizations.
Limit - Control access to pages in a number of different ways.
Options - Similar access to Indexes but includes even
more values such as ExecCGI, FollowSymLinks, Includes and more.
Full .htaccess Overriding
I’ll show some examples, without their corresponding sections.
Here is an example that allows full .htaccess overriding:
# Allow .htaccess files their full power
AllowOverride All
Limited Overriding
And here is an example that takes a more fine grained approach and only allows
overriding of the Authorization and Indexes contexts but nothing else:
# Only allow .htaccess files to override Authorization and Indexes
AllowOverride AuthConfig Indexes
Comments
The first line in both of these examples are Apache comments. Comments start
with the “#” symbol. This is common to many configuration files and scripting
languages. I’ll have plenty of comments in my examples to help explain what things do.
However, they are not required, and it’s really just personal preference on how much you
want to comment. Comments are not required.
The second line is the AllowOverride directive itself. This is the usual syntax of an
Apache Directive. First there is the Directive name “AllowOverride” followed by a space
separated list of values. Although this syntax looks rather loose; always be careful.
Sometimes even a single error in your httpd.conf or .htaccess file will result in a
temporary meltdown of the server, and users will see 500 - Internal Server Error pages.
For that reason alone, it’s good practice to always make a backup of your httpd.conf and .htaccess files before you make a change or addition. This way, if anything goes wrong with a modification, you will have
nothing to worry about, because you can revert to your previous working version. I will
also encourage you to make small changes at a time and verify that the changes work in
increments as opposed to making a number of changes at once. This way, if you make
an error, it will be much easier to track down what may have caused it.
If you are ever confused on the syntax of any directive, immediately go to the
Apache Directive listing and review the “Syntax” they have listed in the table
for each individual directive. I will do my best to try and explain it here
(I am trying to teach) but my explanation can never be as good as the
formal technical documentation itself. Never be afraid of the documentation, it is
your most reliable and trustworthy reference. I’ll try to make things more interesting
here (woohoo!), but in the end, I’m just putting a different spin on those docs.
Checking if .htaccess is Enabled:
It’s quite possible, in fact it’s extremely likely, that your hosting company does not
give you access to the httpd.conf file. So how do you know if .htaccess support is enabled
or not? Don’t worry, .htaccess is a very common and useful feature that most companies will
have enabled, or will enable if you ask politely.
The best thing to do would be to just check with your hosting company. If it’s not explicitly
listed anywhere in your hosting plan, then shoot their support an email. This is a relatively common
question so they mostly likely already have a response ready for you. They will likely be willing
to enable the service or at least give a reason why they may not allow it.
In any event, you can always give it a shot and see if a simple .htaccess file works!
Included in this tutorial’s sample download are two ways which you can check to see if .htaccess
support is enabled. The two folders are “is_htaccess_enabled” and “is_htaccess_enabled_2”.
Give them a shot, I’ll explain what each one is doing here.
is_htaccess_enabled
This test case is very simple. It uses a directive to make Apache look
first for the “indexgood.html” file before “index.html.” If .htaccess support is
enabled, when you point your browser to the folder, Apache will load the .htaccess file and know that
it should display the “indexgood.html” page containing a green message saying Congratulations!
If .htaccess support is not enabled then Apache will, by default, ignore the .htaccess
file and immediately look for an index.html file.
# This Directive will make Apache look first
# for "index_good.html" before looking for "index.html"
DirectoryIndex index_good.html index.html
DirectoryIndex
The DirectoryIndex directive takes a space separated list of potential filenames.
When Apache is given a URL of a directory, and not a direct page (for example
http://www.example.com and not http://www.example.com/index.html) Apache will use this
list of files to search for the proper page to load. Apache will look for the files
using the values in the list from left to right. The first file that Apache sees exists
will be the file that it loads and displays to the client.
Using the above .htaccess file, here is an example of the good (enabled) and bad (disabled) cases:
is_htaccess_enabled_2
As I said earlier, a syntax error in your .htaccess file will cause the server to hiccup.
You can use this to your advantage to test if your server has .htaccess support enabled!
Here is an example of an .htaccess file that is intended to blow up.
# This file is intended to make Apache blow up. This will help
# determine if .htaccess is enabled or not!
AHHHHHHH
It’s pretty clear that “AHHHHHHH” is not a valid Apache directive. This will cause
an error if Apache tries to read the .htaccess file! So, if you get back a page yelling
“Internal Server Error” then your server is looking for .htaccess files! If you actually
see the contents of the index.html file, then it is likely that they have been disabled. Here again are the good and bad cases:
AccessFileName
Finally, it is still possible that .htaccess support is still enabled, just with
unique settings. Systems administrators can change the name of the .htaccess file just
like we changed the name of the default file Apache looks for. This is possible by
using the AccessFileName
directive in the global configuration file. Again, the best thing to do in that case would be to
contact your hosting company for more information.
Consequences of .htaccess files:
Before I get into some of the cool things you can do with .htaccess files, I have to
tell you what you’re getting into. As I mentioned previously you’re allowing
overriding server settings for a directory and all of its subdirectories. Always
keep in mind that you’re affecting all of the subdirectories as well as the current
directory.
Also, when enabled the server will take a potential performance hit. The reason is because, every server request, if .htaccess support is enabled, when Apache goes to fetch the requested file for the client, it has to look for a .htaccess file in every single directory leading up to wherever the file is stored.
This means a number of things. First because Apache always looks for the .htaccess files
on every request, any changes to the file will immediately take effect.
Apache does not cache them, and it will immediately see your changes on the next request.
However, this also means that Apache is going to have to do some extra work for every request.
For example, if a user requests /www/supercool/test/index.html, then your server
would check for the following .htaccess files:
/www/.htaccess
/www/supercool/.htaccess
/www/supercool/test/.htaccess
These potential file accesses (potential because the files may not exist) and their
execution (if they did exist) will take time. Again, my experience is that it’s
unnoticeable and it doesn’t outweigh the benefits and flexibility that .htaccess
files provide developers.
However, if this does concern you, as long as you have access to the httpd.conf file
then you can always put your directives there. By setting AllowOverride to “None”
Apache will not look for those .htaccess files. If you really want to, you can put
the directives you wanted to put in your /www/supercool/test/.htaccess file
directly in httpd.conf like so:
# Put Directives Here
The disadvantage with this approach is that you will have to restart the Apache server
on every change so that it reloads the new configuration.
In the end it comes down to personal preference or whatever your host allows.
I prefer using .htaccess files because I have the flexibility to place them where
I want, and their effects are live immediately without requiring a server reset.
Starting Simple - Directory Listing - Indexes:
Directory Listings
Before getting into any of the complex features, let’s start with something
simple, but useful, so that you can gain a feel for working with .htaccess files.
Directory Listings are so common that you’ve probably come across them numerous
times browsing the web.
When a user requests a directory, Apache first looks for the default file. Typically, it will be named “index.html” or “index.php” or something similar. When it doesn’t
find one of these files, it falls back on the mod_autoindex module to
display a listing of the files and folders in that directory. Sometimes this
is enabled, sometimes disabled, and sometimes you want to
make customizations. Well, with .htaccess you can easily manipulate these listings!
By default Directory listings are enabled. Here is an example scenario.
Suppose you have a bunch of media files that you’re storing on your web server,
and you want to hide them from the public and search engines so that no one can
steal these files. That’s very easy to do! Simply create a .htaccess file
in the directory that you want to hide and add the following directive:
# Disable Directory Listings in this Directory and Subdirectories
# This will hide the files from the public unless they know direct URLs
Options -Indexes
Options Directive
Breaking this down we are using the Options directive.
This directive can take a number of values (mentioned previously). If you provide the values
with a + or - like I did with -Indexes, then this will inherit the
Options that were enabled in higher directories and the global configuration!
If you don’t provide a + or - then the list that you provide will become
the only options enabled for that directory and its subdirectories. No other options will be enabled. Because you may not know which Options were enabled previously, you will most likely
use the + or - syntax unless you are absolutely sure you only want certain Options.
Now, with that directive in your .htaccess file, when you point your browser to that directory
you will no longer be able to see the files. Here is the before and after:
Forge Ahead - Basic Authentication
Okay, maybe totally disabling the Directory Index is not what you want. It’s more
likely that you want to keep the Indexes but only allow certain people access.
That is where Basic Authentication can be very useful. This is the most common
type of Authentication on the web. When the user tries to access the page they
will see the familiar Username/Password dialog. Only a user with the proper
credentials will be able to access the contents.
For basic authentication there are just two steps.
Setup a file that stores usernames and password (encrypted).
Add a few lines to .htaccess to use that file.
Traditionally web developers have named the file that store the usernames and
passwords “.htpasswd”. This is because the command line tool that ships with
Apache that generates the proper encrypted username/password pair is actually
called htpasswd! If you feel comfortable at the command line you can use the htpasswd
tool, however there are plenty of online tools which will generate the output just as easily.
I created a sample .htpasswd file for a user “joe” with password “cool”.
I threw those values into the linked online tool and it produced:
joe:$apr1$QneYj/..$0G9cBfG2CdFGwia.AHFtR1
Your output might be different, that is okay. The passwords are hashed with
a random salt to make them a bit more unique and secure. Once your username
and password combination has been added to the .htpasswd file, then you should
add the following lines to your file:
# Enable Basic Authentication
AuthType Basic # This is what will be displayed to the user on the login dialog.
AuthName "Access to the Hidden Files" # This you must edit. It is the absolute path to the .htpasswd file.
AuthUserFile /path/to/.htpasswd # This allows any user from inside the .htpasswd file to access the
# content if they provide the proper username and password.
Require valid-user
Those commands are well documented. The only real challenge is that you
have to properly set the path to the .htpasswd file that you just
generated. This is a full absolute path from the absolute root of the
server. Also, because the .htpasswd file path is absolute, it’s good
practice to put it in a directory outside the directory where Apache
serves webpages to the public. That way malicious users won’t be able
to easily gain access to the raw listing of users/passwords stored in the .htpasswd.
Once it’s all set up, when someone attempts to access the page they will
receive the following dialog:
Basic Authentication is nice and easy, but it’s not a total solution.
Passwords are sent over the wire, Base 64 Encoded, in plain text. If you
want more secure authentication you should couple Basic Authentication
with https, a more
secure protocol. That is a topic for another time.
Headers
The core protocol of the web is the Hypertext Transfer Protocol (HTTP).
If you really want to understand what the rest of the Apache directives
deal with, you should have some knowledge of the protocol. I’m
only going to su pplya very quick summary here. I’ll also make an effort
to explain what the more complex directives are doing, but it will make
more sense if you understand HTTP Headers.
The quick summary is that HTTP is stateless. With every request (from the browser)
and every response (from the Web Server like Apache) there are two sections.
A section of Header information, then an optional section containing the data itself,
if there is any data.
Request header information often specifies the file they are
requesting from the server (index.html), any state information they should provide
(such as cookie data), and the mime types it’s willing to accept back from the server
(text/html or even gzip encoded content).
Response header information often specifies generic server information (Apache, PHP,
Perl versions etc.), the content encoding, length, mime/type, and more. There
are a plethora of HTTP headers to specify even more details like Cache Control,
Redirects, and Status Codes. Ever get a 404? That was a result of requesting a
file the server couldn’t find, and thus it sent back a 404
Status Code in its
Response.
What does this have to do with .htaccess? Well, you can use Apache directives to
overwrite (set) or add new headers (add) which are sent back to the client
in the Response’s Header section. Also, as you will see in later tutorials,
more advanced functionality such as URL Rewriting deals with the incoming headers.
Let’s start simple, we’ll add a header to the Response and see what happens:
# Add the following header to every response
Header add X-HeaderName "Header Value"
Requesting a file in the same directory as this .htaccess file shows the
extra header:
You probably thought it was peculiar that I prefixed the custom header with
“X-”. This is actually a common convention that developers use to denote that
the header is a non-standard header. This makes it really easy to realize that this header is custom. This convention is
briefly mentioned here.
On a more comical note, some people have had a bit of fun with headers.
This site
points out some rather unusual headers found all over the web.
However, I really want to show you how to create Headers so that you can
use them as a debugging technique. Just the other day, I ran a test to
check to see if certain modules were enabled on a web-server. I wrote
the following check:
Header add X-Enabled mod_gzip
Header add X-Enabled mod_deflate
When I made my next request with my browser and checked the Response Headers, it
showed that neither of the modules were turned on! I contacted my hosting company, and they agreed to enable gzip compression!
There is a difference between Header set and
Header add. With add, the Header will always get added
to the Response. Even if it happens to show up multiple times in the response. This is most often
what you would want for custom headers. You would use set when you want to
override the value of one of the default headers that Apache returns. An
example would be overriding the mime/type specified by the Content-Type
header for a certain file. Apache would set the internal value and then
use that when it prints out the default header. There will be no
duplicates, and thus no possibility for interpreting an error or confusion
by the client. (In case you were wondering, the HTTP specification states that, in
the case of duplicates, the client should always use the last value specified
for that duplicate header.)
Conclusion:
I’ve gone over some basic Apache directives in quite a bit of detail. I wanted to get the fundamental details out of the way so that the next tutorial may discuss cooler things. My next article will
focus on some of the more useful features you can enable with .htaccess.
These topics will include:
GZip encoding of content for both Apache 1.3 and Apache 2
A through description of mod_rewrite and plenty of examples
that are dissected and explained in detail.
Follow us on Twitter, or subscribe to the NETTUTS RSS Feed for more daily web development tuts and articles.
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/gDtzFr2PSgg/
Après avoir un serveur de Google en vidéo, voilà donc un Data Center de Google dans son ensemble. Quelle usine à gaz :) Article original écrit par Philippe LAGANE et publié sur AccessOWeb
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/YQdBEOcVjWY/Un-Data-Center-de-Google-en-video_a5064.html
Prendre
conscience de l'utilité des outils de travail collaboratif, les
choisir et les installer dans votre entreprise est une chose, faire
changer les habitudes de travail de vos collaborateurs (et d'abord les
vôtres) en est une autre. On perçoit bien l'intérêt immédiat de se
rendre sur un site collaboratif quand on cherche de l'information, on
le sent moins quand il s'agit d'y aller pour publier ce qu'on produit,
car cela introduit une rupture dans le rythme de travail, difficile à
intégrer dans les habitudes : ouvrir un navigateur Web, accéder au
site, se connecter, cliquer sur le bon lien, ouvrir l'éditeur, attacher
un document, mettre des mots-clés, publier, notifier… stop !
Un début de solution consiste à
introduire ces opérations dans les étapes-clés de nos processus de
travail actuels, en particulier la sauvegarde d'un document et l'envoi
d'e-mails. Word 2007 permet déjà de publier un document dans
Sharepoint, un blog, ou même l'excellent Drupal. Les outils blueKiwi et Jive SBS (entre autres) vous permettent de publier des notes en envoyant un e-mail, et MindUp
transforme les échanges d'e-mails en forum structuré. Mais ces
fonctionnalités sont encore imparfaites et surtout elles ne font que
retarder le changement de mode de travail.
Une autre voie consiste à commencer par
une application basique nativement collaborative, à effet positif
immédiat. Par exemple, dans une équipe, vous pouvez remplacer tout le
travail sur MS Office par les équivalents Google Docs ou Zoho.
Les collaborateurs voient immédiatement les avantages (tout le monde
travaille sur le même document, on ne se renvoie pas d'e-mail à chaque
version, on sait toujours où on en est, les commentaires sont en un
seul endroit, on peut même travailler offline), et l'adoption
est rapide. Bien plus, la contagion peut s'étendre à d'autres outils
tels que le calendrier partagé, comme l'atteste ce témoignage.
Le but est en fait qu'il n'y ait plus de
frontière mentale entre l'ordinateur et l'espace collaboratif, que le
travail produit, reçu, commenté, modifié soit perçu « dans le même
lieu », à la fois personnel et collectif. On en est encore loin. Pour
l'adoption plus massive des outils du Web 2.0 et le changement de
culture, il faudra bien sûr d'autres approches, mais les esprits seront
déjà préparés.
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/3IiS2HsRklE/adoption-des-outils-collaboratifs-le-diable-est-dans-les-d%C3%A9tails.html
Pour favoriser le déploiement d'applications Java sur sa plate-forme de Cloud Computing AWS, Amazon a développé un plugin pour l'environnement de développement Open Source Eclipse.
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/LPfdHAIsjZM/0,3800005311,39388987,00.htm
La revue de presse de l’actualité Java/J2EE hebdomadaire proposée par Xebia.
Agilité
Votre équipe est-elle cross-fonctionnelle ?
RIA
Un état de l’art, vu par les évangélistes.
La bataille (des annonces) fait rage dans l’univers Mobile.
Le coin de la technique
Sortie de Spring 3.0 M2
Sortie de GridGain 2.1.1
Un petit GIN ?
L’initiative Swing 2 critiquée
Lire la suite de cet article …
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/iWUP6ZjpfWQ/
La plupart des sites et applications sont dynamiques, et la façon la plus répandue de faire passer des informations de page en page est d’utiliser l’URL, en lui passant des paramètres (GET).
Qu’est ce qu’une URL propre ? C’est une URL qui contient des mots-clés pour les moteurs de recherche, et qui est facile à taper pour l’utilisateur (on proscrit donc les URLs à rallonge, où les paramètres foisonnent). Nous allons le voir dans cet article, avoir des URLs propres est l’une des optimisations les plus importantes à mettre en place sur son site ou application web.
Cet article présente une alternative 100% Java au module mod_rewrite d’Apache que l’on utilise habituellement pour manipuler et nettoyer les URLs : UrlRewriteFilter vous permettra d’effectuer facilement les mêmes manipulations sans Apache, directement dans votre application web Java.
Lire la suite de cet article …
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/KggTh5vqPPA/
La revue de presse de l’actualité Java/J2EE hebdomadaire proposée par Xebia.
Actualité éditeurs / SSII
Glassfish v2.1 et Glassfish Portfolio
GlassFish Mobility Platform 1.1
RIA
Mozilla Labs sort Bespin, un IDE web
Blaze Data Service ou LiveCycle Data Service
Le coin de la technique
Sonar en version 1.6
Groovy 1.6, tout pareil, mais en mieux
AribaWeb passe en OpenSource
Maven 2.0.10
Lire la suite de cet article …
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/ZFATqx7MDDk/
Hello and welcome to the first part of what will hopefully be an extensive series covering core aspects of the JavaScript programming language and the DOM API.
While frameworks such as jQuery, Prototype and MooTools are great ways of suppressing browser bugs and speeding up development, it’s important to know and understand the underlying technologies. This series intends to tell you what you need to know about JavaScript and the Document Object Model (DOM). Even if you swear by a particular library this will still benefit you - knowing how something works under the skin can only be a good thing!
Introductions
JavaScript
JavaScript is a dynamic, loosely typed, prototype-based programming language which is used in many different environments. As well as being the prevalent client-side programming language of the web, it’s also used to write plugins for IDEs, in PDF files and as a basis for other platforms and higher abstractions.
JavaScript is based on the ECMAScript standard (ECMA-262) and was created by Brendan Eich of Netscape. It was originally called LiveScript but it was later renamed to JavaScript, probably with the sole intention of causing confusion.
Here are some of its features in a little more detail:
Dynamic programming languages execute at runtime; they are not compiled. Because of this, JavaScript is sometimes considered a scripting language as opposed to a true programming language (obviously a misconception). When you have JavaScript within an HTML document it will be parsed as the page loads within the browser, hence at "runtime".
Loosely typed languages do not insist upon any strong typing system. If you’ve programmed in C or Java (not the same as JavaScript) you’ll know that when declaring a variable you have to specify a type such as ‘int’ (integer). JavaScript is different in that you don’t need to specify the type.
To perform inheritance within JavaScript you have to use something called prototypes. JavaScript does not support classes.
JavaScript is also a functional language. It treats functions as first-class objects; this is the idea behind lambda.
Understanding the above points is not important in learning about JavaScript; it’s just a few ideas to get your brain in gear, and should help you differentiate JavaScript from other programming languages you may have experienced.
Document Object Model
The Document Object Model, normally abbreviated to DOM, is the API through which JavaScript interacts with content within a website. JavaScript and the DOM are usually seen as a single entity since JavaScript is most commonly used for this purpose (interacting with content on the web). The DOM API is used to access, traverse and manipulate HTML and XML documents.
A basic outline of the typical DOM hierarchy (Simplified)
Here’s a few noteworthy things about the DOM:
The window object serves as the global object, you access it by just typing "window". It’s within this object that all of your JavaScript code is executed. Like all objects it has properties and methods.
A property is a variable stored under an object. All variables created on a web-page authomatically become properties of the window object.
A method is a function stored under an object. Since all functions are stored under (at least) the window object they can all be referred to as ‘methods’.
The DOM creates a hierarcy corresponding to the structure of each web document. This hierarchy is made up of nodes. There are several different types of DOM nodes, the most important are ‘Element’, ‘Text’ and ‘Document’.
An ‘Element’ node represents an element within a page. So if you have a paragraph element (’’) then it can be accessed through the DOM as a node.
A ‘Text’ node represents all text (within elements) within a page. So if your paragraph has a bit of text in it can be directly accessed through the DOM.
The ‘Document’ node represents the entire document. (it’s the root-node of the DOM hierarchy/tree).
Also note that element attributes are DOM nodes themselves.
Each layout engine has a slightly different implementation of the DOM standard. For example, the Firefox web browser, which uses the Gecko layout engine, has quite a good implementation (although, not entirely inline with the W3C specification) but Internet Explorer, which uses the Trident layout engine is known for it’s buggy and incomplete implementation; a cause of much anguish within the web development community!
Download Firebug
If you’re using Firefox and you don’t already have the Firebug addon I recomend you download and install it now. It’s a very useful tool for getting a decent picture of the entire document structure.
JavaScript on the Web
The Script Element
When you want to use JavaScript on a website it has to be included within a SCRIPT element:
JavaScript! //
As you can see we’ve got a SCRIPT element at the bottom of our document. The TYPE attribute should strictly be set to ‘application/javascript’ but to no surprise that doesn’t work in Internet Explorer so we’re stuck with either ‘text/javascript’ or no TYPE attribute at all. If you care about validation then the former suggestion will probably suit you.
Remember to specify your scripts as CDATA!
You’ll also have noticed that within that SCRIPT element we have a couple of commented-out lines. These inform XHTML-supporting browsers that the content of the SCRIPT element is ‘character data‘ and should not be interpreted as XHTML markup. It’s only really necessary if you plan on using either the ‘’ characters in your JavaScript code. Obviously you can forget about all this if you’re using plain HTML.
The Defer Attribute
Any JavaScript we put inside that SCRIPT element will run as the page loads. The only exception is when a SCRIPT element has a ‘defer’ attribute. By default, when a browser meets a SCRIPT element, it will stop and run the code, then it will carry on parsing the document. The DEFER attribute informs the browser that the code contains no document-altering code and so can be run later. The only problem with this is that it only works in IE, so it’s probably best to avoid this attribute.
Linking to External Scripts
If you want to link to an external script file then simply add an SRC attribute to your SCRIPT element corresponding to its location. It’s normally a better idea to have seperate script files than to write code inline as it means the browser can cache the file. Plus you don’t need to worry about any of that CDATA nonsense:
JavaScript essentials
Before we continue with the DOM it’s a good idea to have a basic grasp of some JavaScript essentials. If you have trouble understanding some of these, don’t worry - you’ll eventually pick them up!
In JavaScript you can have different types of values. There are Numbers, Strings, Booleans, Objects, Undefined and Null:
Single-line comments are written using two forward slashes (//), all remaining text on that line is assumed to be a comment by the parser. Multi-line comments are signified using ‘/*’ and ‘*/’ to finish the comment.
Numbers
In JavaScript all numbers are represented as floating-point values. When defining a number variable remember not to wrap it in any quotes.
// Note: ALWAYS use 'var' to declare a variable:
var leftSide = 100;
var topSide = 50;
var areaOfRectangle = leftSide * topSide; // = 5000
Strings
Any string you define is taken literally, JavaScript will not process it. A string is a sequence of Unicode characters and should be wrapped in a matching pair of either single or double quotes.
var firstPart = 'Hello';
var secondPart = 'World!';
var allOfIt = firstPart + ' ' + secondPart; // Hello World!
// The + sign is used as the string-concatenation operator
// (it's also used for numerical addition)
Booleans
Boolean types are useful when you want to evaluate a condition - to see if it meets a specified criteria. There are only two possible Boolean values: true and false. Any comparison, using logical operators, will result in a Boolean.
5 === (3 + 2); // = true
// You can assign Boolean values to variables:
var veryTired = true;
// You can test for it like this:
if (veryTired) { // Sleep
}
The ‘===’ you see above is a comparison operator, we’ll cover them later.
Functions
A Function is a specialised Object:
// Using the function operator to create a new function:
function myFunctionName(arg1, arg2) { // Function code goes here.
} // If you omit the function's name then
// you're creating an "anonymous function":
function(arg1, arg2) { // Function code goes here.
} // Running a function is simply a case of referencing it
// and then adding a parenthesis (with arguments):
myFunctionName(); // No arguments
myFunctionName('foo', 'bar'); // with arguments // You can also run a function without assinging
// it to a variable: (function(){ // This is known as a self-invoking anonymous function
})();
Arrays
An Array is also a specialised object and can contain any number of data values. To access data values within an array you must use a number, referred to as the ‘index’ of the item you’re trying to retrieve:
// 2 different ways of declaring a new array, // Literal:
var fruit = ['apple', 'lemon', 'banana']; // Using the Array constructor:
var fruit = new Array('apple', 'lemon', 'banana'); fruit[0]; // Access the 1st item of the array (apple)
fruit[1]; // Access the 2nd item of the array (lemon)
fruit[2]; // Access the 3rd item of the array (banana)
Objects
An Object is a collection of named values (key - value pairs). It’s similar to an array, the only difference is that you can specify a name for each data value.
// 2 different ways of declaring a new Object, // Literal (curly braces):
var profile = { name: 'Bob', age: 99, job: 'Freelance Hitman'
}; // Using the Object constructor:
var profile = new Object();
profile.name = 'Bob';
profile.age = 99;
profile.job = 'Freelance Hitman';
If/Else Statement
One of the most common constructs in JavaScript is the ‘IF’ / ‘ELSE’ statement. It goes something like this:
var legalDrinkingAge = 21;
var yourAge = 29; if ( yourAge >= legalDrinkingAge ) { // We can use 'alert' to notify the user: alert('You can drink.');
} else { alert('Sorry, you cannot drink.');
}
JavaScript Operators:
Instead of listing them all out here I suggest you visit the MDC article on Operators. It explains them in a lot of detail. I’ve setup a few examples to give you an idea of how some of the operators are used below:
// additioa/substraction/multiply/divide
var someMaths = 2 + 3 + 4 - 10 * 100 / 2; // Equality
if ( 2 == (5 - 3 ) { /* Do stuff */ } // == checks for eqaulity // Inequality
if ( 2 != (5 - 3 ) { /* Do stuff */ } // Strict Equality operators:
// (I suggest using these)
2 === 2 // Instead of 2 == 2
2 !== 3 // Instead of 2 != 3 // Assignment:
var numberOfFruit = 9;
numberOfFruit -= 2; // Same as "numberOfFruit = numberOfFruit - 2"
numberOfFruit += 2; // Same as "numberOfFruit = numberOfFruit + 2"
Looping
Looping is useful when you need to go through all items in an array or all members of an object. The most common way to loop in JavaScript is by using either the FOR or WHILE statement.
var envatoTutSites = ['NETTUTS','PSDTUTS','AUDIOTUTS','AETUTS','VECTORTUTS']; // WHILE loop
var counter = 0;
var lengthOfArray = envatoTutSites.length;
while (counter < lengthOfArray) { alert(envatoTutSites[counter]); counter++; // Same as counter += 1;
} // FOR loop
// (The i stands for "iterator" - you could name it anything)
for (var i = 0, length = envatoTutSites.length; i < length; i++) { alert(envatoTutSites[i]);
}
FOR loops are more popular for looping through Arrays.
Back to the DOM
Accessing DOM nodes
Let’s assume we have a basic XHTML document containing a paragraph and an unordered list:
JavaScript! My first paragraph... List item 1 List item 1 List item 1 List item 1 List item 1 //
In this first example we’re going to access our paragraph by using the ‘getElementById’ DOM method:
(This code goes within the SCRIPT element in the above template).
var introParagraph = document.getElementById('intro');
// We now have a reference to the DOM node. This DOM
// node represents the intro paragraph.
The variable ‘introParagraph’ is now a reference to the DOM node. We can do a number of things with this node, - we can query its content and attributes, and can manipulate any aspect of it. We can remove it, clone it or move it to other parts of the DOM tree.
Anything which is present within a document we can access using JavaScript and the DOM API. So, we might want to access the unordered list in a similar fashion, the only problem is that it doesn’t have an ID. You could give it an ID and then use the same method as above or we could access it using ‘getElementsByTagName’:
var allUnorderedLists = document.getElementsByTagName('ul');
// 'getElementsByTagName' returns a live node collection/list
// - It's very similar to an array with a few slight differences.
getElementsByTagName
The ‘getElementsByTagName’ method returns a live node collection/list. It’s similar to an array in that it has a length property. One important thing to note is these collections are "live" - if you add a new element to the DOM then the collection will update itself. Since it’s an array-like object we can access each node via an index, from 0 to the total length of the collection (minus 1):
// Access single unordered list: [0] index
var unorderedList = document.getElementsByTagName('ul')[0]; // Create Node list of all list items within the UL:
var allListItems = unorderedList.getElementsByTagName('li'); // Now, we can loop through each list item using a FOR loop:
for (var i = 0, length = allListItems.length; i < length; i++) { // Extract text node within and alert its content: alert( allListItems[i].firstChild.data );
}
Accessing nodes and attributes within the DOM
Traversing the DOM
The term "traverse" is used to describe the action of travelling through the DOM, finding nodes. The DOM API gives us plenty of node properties which we can use to move up and down through all the nodes within a document.
These properties are inherent of all nodes and enable you to access related/close nodes:
Node.childNodes: You can use this to access all direct child nodes of a single element. It will be an array-like object, which you can loop through. Nodes within this array will include all the different node types including text nodes and other element nodes.
Node.firstChild: This is the same as accessing the first item in the ‘childNodes’ array (’Element.childNodes[0]‘). It’s just a shortcut.
Node.lastChild: This is the same as accessing the last item in the ‘childNodes’ array (’Element.childNodes[Element.childNodes.length-1]‘). It’s just a shortcut.
Node.parentNode: This gives you access to the parent node of your current node. There will only ever be one parent node. In order to access the grandparent you would simply use ‘Node.parentNode.parentNode’ etc.
Node.nextSibling: This gives you access to the next node on the same level within the DOM tree.
Node.previousSibling: This gives you access to the last node on the same level within the DOM tree.
Traversing a document (Simplified - please read below)
So, as you can see, traversing the DOM is incredibly easy, it’s just a case of knowing the property names.
One thing to note about the above graphic: the list items can only be retrieved in that fashion if there is no whitespace between them. Because you can have text nodes and element nodes in a document the space in between the ‘’ and the first ‘’ actually counts as a node itself. Similarily the unordered list is not actually the paragraph’s next sibling - since it’s on a new line there is space between the two elements - hence, another node! Normally, what you’d do in this situation would be to loop through the ‘childNodes’ array and test the ‘nodeType’. A ‘nodeType’ of 1 means it’s an element, 2 means it’s an attribute, 3 means it’s a text node. You can see a full list here: https://developer.mozilla.org/En/DOM/Node.nodeType.
That’s all it is!
This is how all major JavaScript libraries work behind the scenes; using native DOM methods and properties to give you access to these elements through a nicely polished abstraction. What seperates you from the framework diehards is that you now have some idea of how to survive without a framework (if you didn’t already)!
Until Next Time…
Well, that’s it for part one. I hope you’ve learnt something from all my ramblings. In the next part of the series we’ll hopefully be focusing on some more applicable examples; we’ll probably be covering the browser event model as well.
In the mean time and if you haven’t already then check out these talks by Doug Crockford (Yahoo! Video site):
Douglas Crockford: “The JavaScript Programming Language”/1 of 4
Douglas Crockford: “The JavaScript Programming Language”/2 of 4
Douglas Crockford: “The JavaScript Programming Language”/3 of 4
Douglas Crockford: “The JavaScript Programming Language”/4 of 4
Thanks for reading!
Subscribe to the NETTUTS RSS Feed for more daily web development tuts and articles.
http://feedproxy.google.com/~r/nettuts/~3/xfDYppzUk8A/
Le serveur d’applications ‘open source’ de la firme gagne en fonctionnalités et en extensibilité
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/3FN3Tjb6qMs/story01.htm
Une bonne nouvelle pour l'accessibilité numérique est à mettre au compte de la CCEN, la Commission Consultative d'Évaluation des Normes (dépendante de la Direction Générale des Collectivités Locales) dans son procès-verbal du 5 février 2009. En effet, la CCEN approuve à l'unanimité le futur décret d'application de l'article 47 de la loi n°2005-102 du 11 février 2005 sur l'égalité des droits et des chances, la participation et la citoyenneté des personnes handicapées.
Par ailleurs, lors de la même séance, le CCEN émet un avis favorable à l'arrêté relatif au Référentiel Général d'Accessibilité des Administrations (RGAA). Il s'agit du premier document concret qui témoigne de l'avancement de cette loi sur l'accessibilité numérique. Il faut à présent encore un passage au Conseil d'Etat pour que le décret d'application de la loi soit publié. Un grand merci à Bob (MC Melun) pour avoir partagé cette nouvelle sur le forum. ...
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/sbG8yaouLUY/653-du-neuf-dans-la-loi-sur-laccessibilit-numrique.html
Le langage Javascript est un langage de script très puissant et qui s'intègre facilement dans les pages PHP.
Smashing Magazine publie un tour d'horizon et propose 50 outils pour réaliser différentes taches en javascript. Par exemple l'utilisation d'outils de débogues, effectuer des tests, valider des formulaires, la sécurité, l'optimisation...
Bien sur l'article propose un tour en plus du Javascript, une petite situation sur les Frameworks Ajax (MooTools, jQuery, YUI, Dojo, Prototype) et quelques scripts utiles liés aux javascripts. 50 Useful JavaScript Tools (0 visite)
http://www.nexen.net/actualites/php/18948-50_outils_en_javascript.php
Le langage Javascript est un langage de script très puissant et qui s'intègre facilement dans les pages PHP.
Smashing Magazine publie un tour d'horizon et propose 50 outils pour réaliser différentes taches en javascript. Par exemple l'utilisation d'outils de débogues, effectuer des tests, valider des formulaires, la sécurité, l'optimisation...
Bien sur l'article propose un tour en plus du Javascript, une petite situation sur les Frameworks Ajax (MooTools, jQuery, YUI, Dojo, Prototype) et quelques scripts utiles liés aux javascripts. 50 Useful JavaScript Tools (0 visite)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/_NvJ6jUFwN0/18948-50_outils_en_javascript.php
By Jacob Gube
JavaScript is a powerful client-side scripting language used in many modern websites and Web applications. In the hands of a skilled Web developer, JavaScript can enhance the user’s experience of the website and provide rich interactive components and features. But even though syntactically simple in nature, JavaScript is often difficult to author because of the environment it runs in: the Web browser. JavaScript’s popularity is evident in emerging technologies, such as Adobe AIR, which use it as a supported language for creating desktop-based applications.
Below, you’ll find 50 excellent tools to help you achieve various tasks involved in authoring JavaScript code. You’ll find useful tools to speed up your coding processes, including debugging tools to hunt down places where your scripts break, unit testing and validation tools to test your scripts in various situations, security vulnerability scanners and code optimization tools to make sure your scripts are light as a feather.
You’ll also find a few new and alternative JavaScript and AJAX frameworks to help you explore options beyond the big names (i.e. MooTools, jQuery, YUI, Dojo, Prototype), in addition to useful scripts to help you accomplish a host of design and development tasks related to JavaScript.
Also, be sure to check out the following related posts:
75 (Really) Useful JavaScript Techniques
60 AJAX- and Javascript Solutions For Professional Coding
jQuery and JavaScript Coding: Examples and Best Practices
50 Extremely Useful And Powerful CSS Tools
JavaScript/AJAX Authoring Tools
jQuery UI
The jQuery UI allows you to design custom user interfaces for Web applications using the jQuery library. With jQuery UI, you can reduce the amount of code you write for common rich interactive features and website widgets. Be sure to check out the jQuery UI Demo page, which showcases some of the things you can accomplish using jQuery UI.
Google Web Toolkit
The Google Web Toolkit (commonly referred to as GWT) is a framework for developing complex and fully featured AJAX-based Web applications. You write front-end code in Java that is later compiled into optimized and cross-browser-friendly JavaScript. GWT puts the focus on Web application development by reducing the need for testing and debugging JavaScript for browser quirks.
Jx
Jx is a JavaScript library for creating graphical user interfaces written on top of the MooTools framework. Jx is distributed with an MIT license and is well documented. Numerous examples as well as thorough and well-organized API documentation is available on the website.
Freestyle Webtop Toolkit
Freestyle aims to reduce the complexity and time involved in deploying Web-based user interfaces by eliminating the separation of client-side and server-side development. With Freestyle, you focus on programming logic and UI design, and it handles the rest (i.e. cross-browser compatibility and DHTML and AJAX development).
Script#
Script# is an AJAX and JavaScript authoring tool that allows developers to write in C#. It also allows .NET developers to leverage their existing knowledge and provides powerful tools associated with the .NET framework.
Aptana Jaxer
Aptana Jaxer is the first “AJAX server” that allows developers to use their AJAX, HTML, JavaScript and DOM knowledge to create fully featured server-side-powered Web applications. With Jaxer, you can even write database queries in JavaScript syntax. Jaxer integrates very well with popular JavaScript libraries such as jQuery, Dojo and Ext JS.
JS Regex Generator
JS Regex Generator helps JavaScript developers write Regular Expressions for matching strings of text. This is commonly done for text-format validation, such as when checking if inputted text has the correct date and email format.
WaveMaker
WaveMaker is open-source software for complete Web application development and deployment. You can find a host of demo applications built and deployed using WaveMaker on the Demo Applications page.
Documentation Tools
JSDoc Toolkit
JSDoc Toolkit makes code documentation a breeze. Written in JavaScript, it helps developers automatically generate templates for JavaScript comments. It’s a great tool for managing large-scale applications developed by teams of developers who have different coding styles.
jGrouseDoc
jGrouseDoc is an open-source project distributed through Google Code under a modified BSD license. It lets developers document and manage their code comments using a format similar to Javadoc’s.
JavaScript Debugging Tools
Firebug
Firebug is an extremely popular and well-regarded front-end debugging tool. It has all the features you’d expect from a JavaScript debugging tool, such as the ability to set breakpoints in your code so that you can step through your script. For people developing outside of Mozilla-based browsers, check out Firebug Lite, which is a JavaScript library you can include in your Web pages to access some of the features of Firebug.
Venkman JavaScript Debugger
Venkman is Mozilla’s JavaScript debugger and an add-on for Gecko-based browsers. Venkman is a robust and fully featured JavaScript debugging environment, with a host of useful features and options, such as code profiling to inspect your script’s performance.
Drosera
Drosera is an excellent debugging tool for Safari and WebKit-based browsers.
Opera Dragonfly
Opera Dragonfly is a robust debugging environment for the Opera browser. Dragonfly allows you to view and inspect errors, debug your scripts and inspect and edit the DOM and CSS on the fly.
NitobiBug
NitobiBug is a browser-based JavaScript object logger and inspector. It runs on numerous browsers, including IE, Safari, Opera and Firefox. It is a powerful tool in helping developers build rich interactive AJAX applications.
DebugBar
DebugBar is an in-browser front-end debugger for Internet Explorer. Much like its Firefox counterparts, it has a robust set of features, such as DOM, JavaScript and cookie inspection. Be sure to check out Companion JS, which is a JavaScript debugging library to be used alongside DebugBar.
Internet Explorer Developer Toolbar
Similar to Firebug, IE Developer Toolbar is an in-browser tool to help you debug front-end code in Internet Explorer. It’s especially handy as a debugging and inspection alternative to Firefox when you’re developing and testing in IE.
JavaScript Testing and Validation Tools
Test - JavaScriptMVC
Test is a JavaScriptMVC component for easily setting up automated unit testing for JavaScript code. It lets you effectively test for DOM events (such as a key press or form submission), thereby lessening development time, oversight and errors associated with manual testing.
JsUnit
JsUnit is a popular unit testing framework for JavaScript code. It’s a JavaScript port from another unit testing framework for Java called JUnit. JsUnit allows you to write test cases and provides tools for automated code execution.
JSLint
JSLint is a Web-based tool for verifying your JavaScript code for errors. It has a ton of features and settings that you can use to customize verification algorithms to suit your needs.
Crosscheck
Crosscheck is an open-source testing framework for JavaScript. Crosscheck is unique because it works independent of environment: you can run tests outside of a Web browser, which avoids discrepancies that occur when testing in various browsers.
YUI Test
YUI Test is a suite of testing utilities that’s part of the YUI library developed by Yahoo!. It has numerous features, such as easy creation of test cases through an intuitive syntax, advanced failure detection and the ability to organize test cases by grouping them into test suites.
J3Unit
J3Unit is an excellent object-oriented unit-testing framework for JavaScript. It gives you a host of options for writing automated test cases and has three modes: Static Mode, Local Browser Mode and Remote Browser Mode.
Regular Expression Tool
The Regular Expression Tool is an online utility that allows you to test your RegEx code against a sample test. It’s a handy tool to have around when you want to quickly test the efficacy of your regular expressions in a variety of example texts.
JavaScript Regular Expression Tester
This is another handy tool for testing regular expressions within the Web browser.
JSLitmus
JSLitmus is a lightweight tool for creating JavaScript benchmarks and performance tests, using an intuitive API.
Security Tools
AttackAPI
AttackAPI is a framework for writing test cases of potential JavaScript exploits and vulnerabilities.
jsfuzzer
jsfuzzer is a fuzzing tool to help you write (and test for) attack vectors in JavaScript.
New and Alternative JavaScript and Ajax Development Frameworks
Clean AJAX
Clean AJAX is an open-source framework for creating AJAX-based applications. Check out the demo page to see it in action.
SAJAX
SAJAX is an excellent toolkit for developing AJAX-based applications. It supports PHP, Perl and Python.
JavaScriptMVC
JavaScriptMVC is a Web application framework based on the MVC software architectural pattern. It speeds up Web development processes and lays down best practices, maintainability and standards as principles in a project’s development.
qooxdoo
qooxdoo is a simple and intuitive AJAX application framework. Be sure to check out the Demo Browser, a Web-based application that allows you to view demos of qooxdoo at work.
SimpleJS
SimpleJS is a small and lightweight JavaScript library that provides developers with useful JavaScript functions for working with AJAX.
Image Manipulation and Graphing
Reflection.js
Reflection.js automatically adds reflections to your images unobtrusively. Also check out instant.js, a similar script that adds an image border and tilts images on a Web page.
typeface.js
typeface.js allows you to embed custom fonts on Web pages, freeing you from having to create images for HTML text.
CanvasGraph.js
CanvasGraph.js is a simple JavaScript library that lets you construct bar, line and pie charts using HTML’s canvas element.
flot
flot is a JavaScript library for plotting data and has been tested to work in most modern Web browsers.
JavaScript Diagram Builder
The JavaScript Diagram Builder is a JavaScript library that consists of a variety of objects and functions for constructing diagrams.
The Dojo Charting Engine
The Dojo Charting Engine is a robust utility for creating components for data visualization, written on top of the Dojo Toolkit.
Useful Utilities and JavaScript Scripts
Processing.js
Processing.js is a JavaScript port of Processing, the open-source data-visualization programming language. Check out examples that use Processing.js.
AJAX Libraries API
Google’s AJAX Libraries API allows you to serve popular JavaScript libraries using its CDN, which reduces the server load on your website.
DamnIT
DamnIT is an error-reporting service that allows you to gather feedback from beta testers after they’ve encountered a JavaScript error. This is perfect for live production testing and as a monitoring tool that helps you track errors and weak spots in your Web applications.
ie7-js
ie7-js is a JavaScript library that forces Internet Explorer to behave like a standards-based browser (like Firefox or Opera). It automatically fixes IE browser quirks and deviations from Web standards, as in the case of its box model.
Lazy loader
Lazy loader is a jQuery plug-in that delays the loading of images so that text content can load first, thereby making image-heavy pages load faster.
JavaScript Code Optimization and Minification Tools
JS Minifier
JS Minifier is a Web-based tool for shrinking your JavaScript code to make it as lightweight as possible.
JSMIN
JSMIN is a popular JavaScript minifier that removes unneeded characters (like spaces and tabs) and comments, thus reducing your script’s file size.
YUI Compressor
The YUI Compressor is another well-regarded JavaScript code-optimization tool developed by Yahoo!.
Scriptalizer
Scriptalizer is a helpful online tool for combining JavaScript files to reduce HTTP requests.
ShrinkSafe
ShrinkSafe is a compression tool that reduces JavaScript file sizes.
SlickSpeed Selectors Test
SlickSpeed is a Web page for comparing the performance of the DOM object selection of various popular frameworks like MooTools and jQuery.
About the Author
Jacob Gube is a Web developer, designer, and founder of Six Revisions, a blog on Web development and design. If you want to connect with the author, you can follow him on Twitter.
(al)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/y-n1tEG-uJ0/
Microsoft a mis en ligne la version release candidate 1 de son navigateur Internet. Les premiers tests montrent qu'Internet Explorer 8 RC1 est bien meilleur que la bêta 2 et surtout plus stable.
http://feediz.01net.com/item-272053-886373723.html
Désormais disponible en version 10g R3, le vénérable moniteur transactionnel Tuxedo continue son adaptation aux architectures orientées services (SOA), (...)
http://www.lemondeinformatique.fr/actualites/lire-oracle-adapte-tuxedo-aux-specifications-sca-27915.html
Les applications de Business Intelligence (BI), figurent parmi les dix technologies clés listées par Gartner pour l'année 2009. Autour de ces outils, le (...)
http://www.lemondeinformatique.fr/actualites/lire-gartner-cinq-predictions-pour-la-bi-d-ici-2012-27905.html
Microsoft a, pour la première fois, contribué à un projet Open Source Apache sous forme de code. L'équipe 'interopérabilité' de l'éditeur, sous la direction (...)
http://www.lemondeinformatique.fr/actualites/lire-microsoft-livre-du-code-a-un-projet-soa-de-la-fondation-apache-27900.html
Ce mois-ci, le pôle Conseil en ergonomie de Benchmark Group a mis en ligne les résultats d’une enquête très intéressante : “Ergonomie des sites Web : le verdict des internautes”. Cette enquête a été menée au cours du mois de novembre 2008 auprès des lecteurs du Journal du Net et de L’Internaute Magazine. L’enquête a recueilli 824 réponses.
Nous vous invitons fortement à la consulter.
Voici quelques informations à retenir :
1- 75% des internautes rencontrent encore «souvent» des difficultés pour trouver ce qu’ils cherchent sur les sites qu’ils consultent, et que 58% sont «souvent» confrontés à des problèmes de navigation.
2- 66% trouvent les contenus des sites «souvent mal présentés» et 47% «l’allure de la page d’accueil souvent peu engageante».
3- 7 internautes sur 10 ne reviennent pas sur un site où ils ont rencontré des problèmes de navigation ou d’orientation.
Finalement, voici un des schémas qui se retrouve dans les résultats de l’enquête que nous souhaitons partagez avec vous.
Qu’en pensez-vous ?
Source : PEG veille pour vous
Billet initialement publié sur Mikimya
http://feedproxy.google.com/~r/Simpleweb/~3/1FyAiHSnCnU/
Quelques jours seulement après la nomination de sa nouvelle PDG, Yahoo reprend contact avec Microsoft. Le New York Times indique ainsi, dans son édition (...)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/9S6k8qPyHTo/lire-les-patrons-de-yahoo-et-microsoft-relancent-les-rumeurs-de-rapprochement-27862.html
Très active depuis sa création, l’association LeMUG.fr dévoile aujourd’hui son site Internet. Il se veut le point central de la communauté MySQL française
http://feedproxy.google.com/~r/silicon/feed/rss/~3/Vamnd8IgLzw/story01.htm
Les budgets IT en France restent à la hausse. Légèrement, alors qu'ils baisseraient au Royaume-Uni et en Allemagne
http://feedproxy.google.com/~r/silicon/feed/rss/~3/qrcyYBGWXfs/story01.htm
C’est le futur de Linux qui se dessine au travers de ces deux nouveaux systèmes de fichiers
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/LuSvRknk6r0/story01.htm
Notre article et le billet de blog sur l'avis de décès des SOA prononcé par Anne Thomas Manes, du Burton Group, ont suscité des commentaires. Le directeur (...)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/1X80Y4LWSf8/lire-avis-de-deces-des-soa-les-reactions-27813.html
Face à l'inflation colossale des données qu'il faut toujours et toujours stocker, la déduplication est-elle la panacée ? Oui, et non...
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/sB32WftxcsU/story01.htm
Depuis maintenant près de 10 ans que la technologie Flash existe, nous sommes maintenant dans une situation de marché où “Flash” désigne plus un écosystème qu’une technologie. Ce n’est d’ailleurs pas un hasard si Adobe parle maintenant de Flash Platform et est en train de transformer un nom de produit en une marque ombrelle.
C’est dans ce contexte que Lee Brimelow publie un article (
Flash is being redefined) où il s’interroge sur la terminologie autour de Flash :
“Flash” tout d’abord qui ne se contente plus de désigner le plug-in mais également les autres technologies d’interfaces riches (comme Air) et les différents produits de la gamme (dont Flash CS4 et Flash Catalyst) ;
“Flex” qui désigne à la fois le framework et l’IDE (sans compter tous les produits qui y sont associés comme LiveCycle) ;
“Développeur Flash” qui recouvre en fait tout une gamme de métiers et de langages (Flash, Action Script, Flex, Java…) ;
“Designeur Flash” qui recouvre également une large palette de métiers (concepteur d’interfaces, graphiste, animateur, sound designeur, spécialiste vidéo…).
Bref, difficile pour le moment de savoir comment la gamme Flash va évoluer mais Adobe aurait tout intérêt à clarifier tout ça pour ne pas noyer les nouveaux entrants dans l’écosysteme Flash.
Bon je ne sais pas pour vous mais moi je n’ai pas encore réussi à trouver ma place dans cet écosystème. Plus grâve, je ne m’y retrouve pas dans le workflow décrit ici : Designer Developer Workflows are Lacking a Critical Component.
http://feedproxy.google.com/~r/InterfacesRiches/~3/bXFUgdu3BTU/
Depuis plusieurs mois le magazine Smashing Magazine publie les outils développeurs pour les différentes CMS connus et développés en PHP.
Pour rappel, un CMS est un gestionnaire de contenu permettant de mettre à jour facilement un site dynamique sur internet.
Ce mois ci, c'est le CMS Joomla qui est mi en avant... Mais Drupal, Wordpress, ExpressionEngine, TextPattern, Movable ont eu aussi leurs articles.
Joomla Developer’s ToolboxWordPress Developer’s ToolboxDrupal Developer’s ToolboxExpressionEngine Developer’s ToolboxTextpattern Developer’s ToolboxMovable Type Developer’s Toolbox
http://www.nexen.net/actualites/php/18898-outils_developpeur_pour_cms.php
Vous possédez une entreprise ou travaillez dans un organisme qui doit diffuser de l’information? L’une des résolutions que vous devriez prendre cette année, ce serait de démarrer un blogue. Pourquoi me direz-vous? Et bien la réponse est simple, je vous répondrais en trois mots: référencement, interaction et diffusion.
Le référencement: votre organisation possède sans doute un site Web. Est-il bien référencé par les moteurs de recherche? Soumettez-vous régulièrement un sitemap à Google? Savez-vous comment facilement améliorer votre référencement? Faire appel à des spécialistes du référencement peut s’avérer être assez coûteux pour une petite organisation. L’implantation d’un blogue est certainement un moyen simple et efficace pour améliorer votre référencement.
En ajoutant quelques plugins, vous automatiserez les tâches fastidieuses et souvent assez compliquées comme soumettre votre sitemap aux moteurs de recherche ou encore intégrer certaines balises HTML dans les entêtes de vos pages.
Par exemple, Wordpress offre plusieurs plugins qui vous permettent d’automatiser des actions afin d’améliorer votre référencement. Parmi les plugins les plus intéressants, vous trouverez :
All in One SEO Pack, optimise votre blogue pour les moteurs de recherche
Google XML Sitemaps, crée automatiquement le plan de votre blogue qu’il soumettra automatiquement à Google, Yahoo et Live Search.
SEO Friendly Image vous permettra d’optimiser les images qui se trouvent sur votre blogue pour qu’elles soient elles aussi bien référencées.
Redirection vous permettra de rediriger les pages mortes qui donnent des erreurs 404 à vos visiteurs.
L’interaction est sans doute l’un des piliers de ce que l’on nomme les blogues. Peut-être utilisez-vous dans votre organisation un CRM. Cet outil vous permet d’avoir le portrait complet de vos clients. Ce qui devrait en théorie devrait faciliter vos relations avec ceux-ci. Le blogue est un peu un CRM inversé. C’est un espace où vous pourrez échanger avec vos clients. Puisqu’il est possible de tout commenter sur un blogue, vos clients peuvent ainsi amorcer une discussion avec vous sur cet espace.
Vous conviendrez que la diffusion de l’information que vous publiez sur le Web est importante. Vous pouvez posséder le plus beau site Web de l’univers, si personne ne le consulte, c’est un coup d’épée dans l’eau. Le blogue a l’avantage de non seulement vous servir de plateforme de publication, mais aussi de diffusion. Toutes les plateformes de blogue intègrent la fonction de flux RSS. Celle-ci vous permettra de diffuser automatiquement à tous vos lecteurs vos publications. En créant un blogue, vous aurez donc non seulement un espace Web, mais aussi un système de diffusion automatisé.
Vous avez sans doute compris qu’à mon avis le blogue est l’un des meilleurs moyens d’affirmer votre présence sur le Web. SI vous obtenez du succès avec cet espace, vous aurez créé votre mini réseau social privé. N’oubliez pas qu’il est important que votre blogue offre du contenu original et de bonnes qualités à vos lecteurs et clients. C’est sans doute la clé du succès.
Benoit Descary
Billets relatifs
Les cinq billets les plus consultés cette semaine sur descary.com
12 raisons de choisir Wordpress comme plateforme de blogue
JournalSpace ferme ses portes parce qu’il n’avait pas de copie de sauvegarde
Joyeux Noël
Les cinq billets les plus consultés cette semaine sur descary.com
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/508594154/
Vous possédez une entreprise ou travaillez dans un organisme qui doit diffuser de l’information? L’une des résolutions que vous devriez prendre cette année, ce serait de démarrer un blogue. Pourquoi me direz-vous? Et bien la réponse est simple, je vous répondrais en trois mots: référencement, interaction et diffusion.
Le référencement: votre organisation possède sans doute un site Web. Est-il bien référencé par les moteurs de recherche? Soumettez-vous régulièrement un sitemap à Google? Savez-vous comment facilement améliorer votre référencement? Faire appel à des spécialistes du référencement peut s’avérer être assez coûteux pour une petite organisation. L’implantation d’un blogue est certainement un moyen simple et efficace pour améliorer votre référencement.
En ajoutant quelques plugins, vous automatiserez les tâches fastidieuses et souvent assez compliquées comme soumettre votre sitemap aux moteurs de recherche ou encore intégrer certaines balises HTML dans les entêtes de vos pages.
Par exemple, Wordpress offre plusieurs plugins qui vous permettent d’automatiser des actions afin d’améliorer votre référencement. Parmi les plugins les plus intéressants, vous trouverez :
All in One SEO Pack, optimise votre blogue pour les moteurs de recherche
Google XML Sitemaps, crée automatiquement le plan de votre blogue qu’il soumettra automatiquement à Google, Yahoo et Live Search.
SEO Friendly Image vous permettra d’optimiser les images qui se trouvent sur votre blogue pour qu’elles soient elles aussi bien référencées.
Redirection vous permettra de rediriger les pages mortes qui donnent des erreurs 404 à vos visiteurs.
L’interaction est sans doute l’un des piliers de ce que l’on nomme les blogues. Peut-être utilisez-vous dans votre organisation un CRM. Cet outil vous permet d’avoir le portrait complet de vos clients. Ce qui devrait en théorie devrait faciliter vos relations avec ceux-ci. Le blogue est un peu un CRM inversé. C’est un espace où vous pourrez échanger avec vos clients. Puisqu’il est possible de tout commenter sur un blogue, vos clients peuvent ainsi amorcer une discussion avec vous sur cet espace.
Vous conviendrez que la diffusion de l’information que vous publiez sur le Web est importante. Vous pouvez posséder le plus beau site Web de l’univers, si personne ne le consulte, c’est un coup d’épée dans l’eau. Le blogue a l’avantage de non seulement vous servir de plateforme de publication, mais aussi de diffusion. Toutes les plateformes de blogue intègrent la fonction de flux RSS. Celle-ci vous permettra de diffuser automatiquement à tous vos lecteurs vos publications. En créant un blogue, vous aurez donc non seulement un espace Web, mais aussi un système de diffusion automatisé.
Vous avez sans doute compris qu’à mon avis le blogue est l’un des meilleurs moyens d’affirmer votre présence sur le Web. SI vous obtenez du succès avec cet espace, vous aurez créé votre mini réseau social privé. N’oubliez pas qu’il est important que votre blogue offre du contenu original et de bonnes qualités à vos lecteurs et clients. C’est sans doute la clé du succès.
Benoit Descary
Billets relatifs
Des images vectorielles gratuites pour votre blogue!
Les cinq billets les plus consultés cette semaine sur descary.com
12 raisons de choisir Wordpress comme plateforme de blogue
JournalSpace ferme ses portes parce qu’il n’avait pas de copie de sauvegarde
Joyeux Noël
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/OwIh8tiEOjQ/
Google Chrome 2.0 is now available in pre-beta form from the folks at GOOG for anyone anxious enough to keep up with the cutting edge releases of Chrome. The 2.0 release boasts several fixes and updated features, including support for user scripts (à la Greasemonkey but not yet full Greasemonkey compatibility), easy profile switching, form autofill (à la every browser in the world), and full page zooming. You'll need to download the Google Chrome Channel Chooser and join the Dev channel if you're ready to get started on the 2.0 path. [via]
http://feeds.gawker.com/~r/lifehacker/full/~3/bDlnYgqqkWo/google-chrome-20-pre+beta-now-available-supports-profile-switching-user-scripts
Cet ouvrage très technique est une mine d’informations intéressantes
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/504798570/story01.htm
Voici quelques jours, la première partie des vidéos du Forum PHP était annoncé.
Maintenant la suite et la fin des autres conférences qui ont été couvertes par PHP TV. PHPTV : Les vidéos du forum PHP 1ere partie (0 visite) Place des Tendances et les interfaces riches Ajax (0 visite) L'importance de PHP dans l'entreprise (0 visite) PHP, a mystery success story! (0 visite)
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/508594156/18894-phptv_:_les_videos_du_forum_php_2eme_partie.php
Voici quelques jours, la première partie des vidéos du Forum PHP était annoncé.
Maintenant la suite et la fin des autres conférences qui ont été couvertes par PHP TV. PHPTV : Les vidéos du forum PHP 1ere partie (0 visite) Place des Tendances et les interfaces riches Ajax (0 visite) L'importance de PHP dans l'entreprise (0 visite) PHP, a mystery success story! (0 visite)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/41KNrw2BO90/18894-phptv_:_les_videos_du_forum_php_2eme_partie.php
La revue de presse de l’actualité Java/J2EE hebdomadaire proposée par Xebia.
RIA
Ajax, le RIA du futur ?
JavaFx cherche le soutient de la communauté Java
Le coin de la technique
Comment plomber une application grâce à de mauvaises pratiques base de données
Evènements de notre communauté en France et à l'étranger
InfoQ fait une rétrospective du contenu le plus lu en 2008
Les vidéos et les présentations des "rencontres Spring" disponibles en ligne
RIA
Ajax, le RIA du futur ?
Le SD Times Blog revient sur 2 expériences réussies de développement d'applications riches en Ajax.
Pour le développement d'un portail destiné aux soldats américains, la firme Roundarch a choisit Ajax. Dave Meeker, leader de la stratégie 'orientée utilisateur', revient sur les raisons de ce choix.
La première raison de ce choix est la valorisation des compétences CSS, HTML et Javascript des équipes de développements. La plupart des développeurs trouvent Ajax facile d'utilisation, lorsqu'il s'agit de développer des applications HTML dynamiques simples.
Un autre argument en faveur de ce choix est qu'au contraire de RIA tels Flex ou Silverlight, Ajax ne demande pas de téléchargement complémentaire, ce qui est un argument de poids quand le déploiement du portail se veut mondial, en particulier dans des pays où le débit et/ou le matériel peuvent poser problème (Afrique, Asie, ...).
Autre entreprise, même son de cloche : Peter Mezzina, leader technique de Powerlink, explique le choix de partir sur Ajax, plutôt que sur un des 12 autres produits benchmarqués par son entreprise. Là aussi, la montée en compétence de ses équipes, facilitée par le choix du framework Dojo Toolkit (un wrapper Java pour Ajax), a été un élément de choix déterminant. Les équipes ont l'habitude de travailler dans un environnement Java, et grâce au wrapper, restent dans leur 'zone de confort' (gain de temps et de productivité).
De plus, selon Mezzina, Ajax est plus stable que les autres RIA testés. Cette stabilité se manifeste plus par un comportement 'prédictible' obtenu par les clients (ou au moins 'débuggable'), que par une diminution sensible des crashs serveur par exemple.
Cependant, Dave Meeker estime que Flex possède de sérieux atouts dans le développement d'applications RIA complexes, en particulier grâce à la volonté de Adobe de rendre son moteur performant même sur des patterns complexes (Meeker cite le "célèbre" exemple du DataGrid, si facile à mettre en place), et/ou sur des volumes de données à manipuler importants (tentez de manipuler 5000 lignes en Javascript sous IE, vous comprendrez).
De plus, alors qu'Ajax est présent sur le marché depuis plus longtemps que les produits de Adobe et Microsoft, aucune implémentation ne sort clairement du lot. Il est donc difficile de 'vendre' Ajax à une DSI, ne sachant pas si la librairie choisie (Meeker prend l'exemple de script.aculo.us) passera l'hiver.
Peut-être qu'un cap sera franchit grâce à l'utilisation de Google Chrome, qui permet, même si le moteur Javascript crashe, de ne fermer que l'application incriminée. De plus, l'attention que Google a portée sur la stabilité et la performance du moteur Javascript, si elle est suivie d'effet chez les navigateurs concurrents, peut se révéler un avantage décisif pour ce langage.
Alors, Ajax va t'il gagner la bataille des RIA ? Comme d'habitude, une seule réponse valable : ça dépend...
JavaFx cherche le soutient de la communauté Java
Jeet Kaul, vice président du groupe 'Applications clients' chez Sun, annonce sur son blog le passage prochain de JavaFx en full open source. Sun travaille actuellement à casser les dépendances entre Fx et certaines portions de code propriétaires.
Les spécifications pour FXD, FXZ, FXM et JavaFX Script devraient être publiées prochainement.
Dans la série des annonces, Kaul confirme l'arrivée de la version mobile pour mars 2009, et l'arrivée d'un outil de design pour mi 2009. Les bugs seront eux fixés au fil de l'eau. A ce sujet, le Jira de FX est maintenant accessible au grand public.
Sun cherche donc à s'appuyer sur un large nombre de développeurs pour combler son retard sur ses concurrents. Ce passage à l'open source est une très bonne nouvelle, et devrait permettre l'émergence rapide de composants de haut niveau sous licence GPL.
Le coin de la technique
Comment plomber une application grâce à de mauvaises pratiques base de données
Une piqûre de rappel ne faisant jamais de mal, Alois Reitbauer revient pour InfoQ, sur quelques mauvaises pratiques dans les interactions applications / bases de données relationnelles.
Profitons donc de la nouvelle année pour rappeler ces mauvaises pratiques à éviter :
Mauvais usage des outils de mapping Objet / Relationnel : même si ces frameworks sont là pour rendre l'accès à la couche de persistance le plus transparent possible, il est bon de connaitre leurs grands mécanismes, pour optimiser la stratégie d'accès aux données (itérations, lazy-loading...)
Chargement excessif de données : la couche DAO doit évoluer avec l'application, et chaque changement de la base doit être l'occasion de se repencher sur celle-ci (dans le cas de l'ajout d'une colonne par exemple). Mais si les interfaces de service nous poussent à tendre vers un maximum de généricité, il est impératif de garder à l'esprit les impacts éventuels de chaque modification de base sur l'ensemble des use cases, quitte à devoir réécrire un service spécifique pour un use case donné.
Gestion des accès à la base : souvent, pour des questions de facilité de développement (lazy loading encore...), les connexions à la DB sont 'tenues' plus longtemps qu'il ne le faudrait. Il est donc impératif de libérer les accès à la base dès que possible (le lazy loading ne devant pas être un frein à cette libération).
Traiter indifféremment toutes ses données : il est impératif de mettre en place des traitements spécifiques pour des types de données à catégoriser (fréquence de changement, fréquence d'accès, use case d'accès). La catégorisation des données (et des requêtes) permet d'adapter les outils techniques (cache, pool de connexion différenciés...) pour optimiser les échanges.
Pas ou de mauvais tests : les tests unitaires de la couche DAO doivent se faire sur des données réelles et dans des conditions réelles d'utilisation (accès concurrents en lecture, lecture / écriture, pics d'accès). Ces tests de charge avant l'heure permettent d'identifier très tôt d'éventuelles erreurs de conception.
Peut-être avez-vous l'impression que nous enfonçons des portes ouvertes en reprenant ici cette interview, mais nous croisons encore ces mauvaises pratiques sur de trop nombreux projets...
Evènements de notre communauté en France et à l'étranger
InfoQ fait une rétrospective du contenu le plus lu en 2008
La semaine dernière nous avons eu l'occasion de présenter la rétrospective des articles de JavaLobby : JavaLobby fait une rétrospective des articles les plus lus en 2008.
Dans le même style, InfoQ nous propose une rétrospective par thèmes : .Net, Agile, Architecture, Java, Ruby, SOA dans Top InfoQ News and Exclusive Content for 2008.
Ainsi au vu des articles les plus consultés dans la communauté Java, les deux acteurs innovateurs ont été :
Adobe avec Flex
SpringSource, avec la nouvelle version de Spring (2.5 et la préparation de la version 3) mais aussi avec son SpringSource dm Server et son SpringSource tc Server.
On peut quand même s'étonner de ne voir aucun article à propos des nouvelles versions du JDK 7 et du JEE 6, en cours d'élaboration.
Cette année 2008 a été aussi marqué par l'évangélisation de l'architecture REST. De nombreuses questions et réponses ont été apportées sur ce sujet. De nombreux travaux sont en cours de réalisation dans ce domaine :
Les spécifications REST se terminent
Restlet 1.1.0: Plus de souplesse et une implémentation de JAX-RS 1.0
Donc si vous avez raté un article important en 2008 sur InfoQ c'est le dernier moment pour vous rattraper !
Les vidéos et les présentations des "rencontres Spring" disponibles en ligne
SpringSource référence sur son blog l'ensemble des vidéos et des présentations des rencontres Spring qui se sont tenues à Paris le 13 novembre 2008.
On notera en particulier la vidéo de Mark Thomas concernant l'amélioration des performances de Tomcat (dont nous nous étions déjà fait l'echo).
http://feedproxy.google.com/~r/XebiaFrance/~3/IQW0IJmBLfU/
Après avoir couvert le forum PHP 2008 organisé par l'AFUP (Association Française des Utilisateurs PHP).
L'équipe de PHP TV, met tous les deux jours la vidéo d'une séance plénière.
En voici la première vague des vidéos : The Age of Literate Machines (0 visite) 20minutes.fr : plus vite, plus lourd, plus alerte (0 visite) Drupal : Rue89 ou la communauté de l'info (0 visite) Industrialisation PHP : Retour d'expérience BNP Paribas (0 visite) Nouvelles fonctionalites Oracle database 11g pour PHP (0 visite) Scaling Mozilla's websites with PHP (0 visite) Performance, en allant plus loin que PHP (0 visite) Static and Dynamic Analysis at Ning (0 visite) PHP 5.3 : les nouveautés du futur si proche (0 visite)
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/508594157/18887-phptv_:_les_videos_du_forum_php_1ere_partie.php
Après avoir couvert le forum PHP 2008 organisé par l'AFUP (Association Française des Utilisateurs PHP).
L'équipe de PHP TV, met tous les deux jours la vidéo d'une séance plénière.
En voici la première vague des vidéos : The Age of Literate Machines (0 visite) 20minutes.fr : plus vite, plus lourd, plus alerte (0 visite) Drupal : Rue89 ou la communauté de l'info (0 visite) Industrialisation PHP : Retour d'expérience BNP Paribas (0 visite) Nouvelles fonctionalites Oracle database 11g pour PHP (0 visite) Scaling Mozilla's websites with PHP (0 visite) Performance, en allant plus loin que PHP (0 visite) Static and Dynamic Analysis at Ning (0 visite) PHP 5.3 : les nouveautés du futur si proche (0 visite)
http://www.nexen.net/actualites/php/18887-phptv_:_les_videos_du_forum_php_1ere_partie.php
Après avoir couvert le forum PHP 2008 organisé par l'AFUP (Association Française des Utilisateurs PHP).
L'équipe de PHP TV, met tous les deux jours la vidéo d'une séance plénière.
En voici la première vague des vidéos : The Age of Literate Machines (0 visite) 20minutes.fr : plus vite, plus lourd, plus alerte (0 visite) Drupal : Rue89 ou la communauté de l'info (0 visite) Industrialisation PHP : Retour d'expérience BNP Paribas (0 visite) Nouvelles fonctionalites Oracle database 11g pour PHP (0 visite) Scaling Mozilla's websites with PHP (0 visite) Performance, en allant plus loin que PHP (0 visite) Static and Dynamic Analysis at Ning (0 visite) PHP 5.3 : les nouveautés du futur si proche (0 visite)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/xSybod3A0fU/18887-phptv_:_les_videos_du_forum_php_1ere_partie.php
Les clients lourds, à installer sur chaque ordinateur, n'ont plus la cote : trop complexes à installer et mettre à jour, incompatibles avec la vaste majorité (...)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/2kRMshpR4W4/lire-bilan-2008-la-guerre-des-ria-reconcilie-soa-mash-up-et-web-2-27736.html
Les clients lourds, à installer sur chaque ordinateur, n'ont plus la cote : trop complexes à installer et mettre à jour, incompatibles avec la vaste majorité (...)
http://www.lemondeinformatique.fr/actualites/lire-bilan-2008-la-guerre-des-ria-reconcilie-soa-mash-up-et-web-2-27736.html
Les clients lourds, à installer sur chaque ordinateur, n'ont plus la cote : trop complexes à installer et mettre à jour, incompatibles avec la vaste majorité (...)
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/503654578/lire-bilan-2008-la-guerre-des-ria-reconcilie-soa-mash-up-et-web-2-27736.html
La revue de presse de l’actualité Java/J2EE hebdomadaire proposé par Xebia.
Le coin de la technique
Sonar en version 1.5
Version finale de Tapestry 5
Première implémentation de la JSR 299 : Web Beans RI 1.0.0.ALPHA1
Evènements de notre communauté en France et à l'étranger
JavaLobby fait une restrospective des articles les plus lus en 2008
Le coin de la technique
Sonar en version 1.5
SonarSource (spin off de la société Hortis dédiée au développement et au support de Sonar) a annoncé la sortie de la nouvelle version de Sonar.
Comme déjà présenté plus en détail sur ce blog, Sonar est un outil open source qui collecte, consolide et présente les données Qualité d'un projet.
Dans les nouvelles fonctionnalités, il est à noter une volonté d'ouverture de l'API :
Récupération des mesures à partir de services REST.
Possibilité d'écrire ses propres extensions via des plugins de collecte (voir le tutorial ici).
Des présentations graphiques des métriques et de l'évolution dans le temps ont été ajoutés :
Suivi des règles sous forme de radar.
Couverture de code présenté en nuages de>
Amélioration de l'affichage des graphiques d'évolution du respects des règles (Time machine).
L'intégration avec les outils open source utilisés lors des collectes est aussi améliorée :
Ajout des règles Findbugs portant à 600 le nombre de règles de codes contrôlables (de la simple règle de nommage à l'anti-pattern).
Mise à jour des versions des plugins PMD et Clover.
La release s'accompagne aussi de son lot de corrections de bugs.
Pour plus de détails, voir la release note complète.
Sonar, avec cette nouvelle version, se positionne encore plus comme un incontournable dans la présentation de données liées à la qualité, loin devant le dashboard Maven.
De plus, la roadmap présentée sur le site de Sonar propose des fonctionnalités intéressantes comme le regroupement de projets, le positionnement d'alerte sur indicateurs ou encore l'association de règles différentes selon les projets ...
Version finale de Tapestry 5
Comme nous l'a fait remarquer un de nos lecteurs, François Armand, Tapestry 5.0 est actuellement disponible en version finale.
Tapestry 5 a nécessité près de 3 ans de développement afin d'avoir les améliorations suivantes (par rapport à la version 4) :
Amélioration du modèle de programmation de Tapestry afin de pouvoir développer des composants "Tapestry" sous forme de POJO
Moins de configuration par XML, et plus de conventions de nommage (principe de CoC, Convention over Configuration), utilisation des nouveautés du langage Java 5 (annotation)
Amélioration de la productivité des développements avec la recharge à chaud des Java en cours de développement.
Le rechargement à chaud de permet de ne plus avoir un cycle de développement suivant :
Modification.
Compilation de l'application.
Packaging de l'application.
Déploiement de l'application.
Démarrage de l'application.
Test de l'application.
Le cycle de développement suivant permet d'être plus productif car beaucoup plus court que le précédent :
Modification d'une>
Compilation de la>
Rechargement de la dans le Classloader de l'application sans le redemarrage de l'application.
Test de l'application.
Pour plus d'informations sur l'intérêt d'un cycle de développement allégé, je vous invite à découvrir ou redécouvrir l'article à propos de JavaRebel.
Je vous propose aussi à lire le commentaire de François sur notre blog, qui fait un tour d'horizon et un retour d'expérience sur Tapestry. Encore une fois, merci François.
Matt Raible (Raible Design) avec l'aide de Serge Eby, ont mis à jour AppFuse afin d'intégrer Tapestry 5. Ils notent d'ailleurs ce qu'ils apprécient dans Tapestry 5 : la configuration, qui est minimale, ainsi que les URLs claires. Pour plus d'informations sur AppFuse, voici une présentation du plugin : AppFuse par l'exemple.
Première implémentation de la JSR 299 : Web Beans RI 1.0.0.ALPHA1
A plusieurs reprises dans cette revue de presse, nous avons parlé de la spécification JSR 299, baptisée WebBeans :
JSR-299 : Web Beans disponible en Public Review Draft.
Seam 3 : les futures orientations de Seam.
Sur la page consacrée à WebBeans sur le site de Seam Framework, une release de WebBeans est maintenant disponible : Web Beans 1.0.0.ALPHA1 released!.
Pour être plus précis sur l'avenir conjoint de Seam et WebBeans : Seam ne va pas devenir WebBeans. Il y aura un noyau WebBeans, et Seam utilisera ce noyau.
Le noyau WebBeans prend en charge le contexte de gestion de composants "WebBeans" ainsi que les mécanismes d'injection de dépendance.
Ainsi Seam embarquera ces propres fonctionnalités :
Seam Security.
Rendu PDF / mail.
Intégration de moteur de workflow (JBPM).
etc ...
Cette release est une première étape importante afin d'achever cette spécification JSR 299 avec une implémentation et sa documentation.
Cette première release vous permettra peut être d'avoir les plus claires sur cette spécification.
Evènements de notre communauté en France et à l'étranger
JavaLobby fait une restrospective des articles les plus lus en 2008
JavaLobby fait le bilan de l'année 2008 en nous montrant les 10 articles les plus lus ces 12 derniers mois. En tête, l'interview de John de Goes président de N-BRAIN qui avoue que les produits open source deviennent de redoutables concurrents et annonce le passage en open source de leur plateforme UNA.
Rick Hightower dont l'un des articles fait partie du top 10 nous fait remarquer dans un commentaire la répartition des résultats en fonction des frameworks.
Voici le résultat :
deux articles sur JSF dans le top 5 montrent que JSF a toujours le vent en poupe. L'un de ces articles parle d'ailleurs de l'interfaçage JSF/Flex.
deux articles sur JPA/Hibernate
un article sur Spring.
Rick Hightower nous précise aussi que les résultats ne prennent pas en compte l'âge des articles. En effet la majorité de ces articles a été publiée avant le mois de Mai.
Globalement, il est intéressant de voir que les frameworks tels JSF et JPA sont toujours aussi populaires et qu'ils intéressent toujours autant les lecteurs.
http://feeds.feedburner.com/~r/XebiaFrance/~3/497915868/
La revue de presse de l’actualité Java/J2EE hebdomadaire proposé par Xebia.
Agilité
Les bases de Scrum, en 10 minutes, avec le sourire.
RIA
Native Client de Google et Alchemy d'Adobe
Spring BlazeDS Integration 1.0.0.M1
Choisir sa solution RIA
Le coin de la technique
OpenXava 3.1 est disponible
Java Persistence API 2.0 Public Draft
Agilité
Les bases de Scrum, en 10 minutes, avec le sourire.
En 2009, je vais tenter de comprendre ce que Xebia raconte dans la partie Agilité de sa revue de presse. Si vous faites cette bonne résolution, alors la vidéo suivante est pour vous ! Hamid Shojaee (Axosoft) résume en 8 minutes les principaux concepts de Scrum.
Cliquer ici pour voir la vidéo.
RIA
Native Client de Google et Alchemy d'Adobe
Google annonce la sortie de Native Client, une technologie permettant d'exécuter du code natif directement dans le navigateur. Le but de Native Client est d'exploiter le processeur et la carte graphique du poste client pour pouvoir mettre en place des applications web plus performantes. Google rassure en disant que cette exploitation ne remettra en cause ni la neutralité du navigateur, ni la sécurité, ni la portabilité des applications sur les différents systèmes d'exploitation.
Il est possible de tester une version expérimentale de Native Client. À noter pour le moment que cette version n'est compatible qu'avec les navigateurs suivants : Firefox, Safari, Opera et Google Chrome; et sur les systèmes d'exploitations suivants : Windows, Mac et Linux qui ont un processeur x86.
Coïncidence ou pas, Adobe a présenté, lors de ses journées Adobe MAX, Alchemy qui offre les mêmes fonctionnalités que Native Client.
Alchemy est un projet d'Adobe Labs permettant d'intégrer du code C ou C++ dans une machine virtuelle ActionScript. Le code C/C++ est d'abord compilé en ActionScript3 dans un swc ou swf. Il peut ensuite fonctionner sur Flash Player 10 ou AIR 1.5, sécurisé par les protections Flash Player.
Quoi qu'il en soit, le but de ces technologies reste le même : faire en sorte que les applications web deviennent plus puissantes. Cela ne devrait donc pas concerner l'informatique de gestion. Mais pour les applications qui demandent beaucoup de ressources, telles que les jeux en ligne par exemple, cela pourrait changer la donne.
Une question reste cependant en suspend. Pourquoi Google a t'il décidé de sortir cette technologie ? Java Applets, ActiveX, Flash, Flex, Air, Silverlight, JavaFX, ce ne sont pas les technologies concurrentes qui manquent. Native Client ressemble d'ailleurs plus à une nouvelle version d'ActiveX cross-browser qu'à une nouvelle technologie RIA au sens Flex ou SilverLight. Certains pensent que cette technologie est le fruit d'un travail indépendant ne répondant à aucune vision technique cohérente à long terme. D'autres, au contraire, pensent qu'il s'agit d'un pas de plus vers un système d'exploitation made in Google. Le débat est ouvert, difficile de s'avancer pour le moment ... Une fois de plus, Google est arrivé à faire le buzz autour de ses technologies.
Pour ceux qui voudraient tester Quake made in Native Client, voici le lien
Spring BlazeDS Integration 1.0.0.M1
Nous en parlions la semaine dernière, c'est maintenant officiel, le premier milestone de Spring BlaseDS Integration est maintenant disponible.
Alors à quoi ressemble cette intégration ? Elle vous permettra de mixer les configurations BlaseDS et Spring à votre guise. L'idée est de laisser les configurations statiques d'infrastructure dans le fichier de configuration BlaseDS et d'externaliser le reste dans les fichiers de configuration Spring. Cette solution devrait donc plaire à tout le monde : les utilisateurs de BlaseDS ne devraient pas être perdus, le mécanisme général restant inchangé ; les utilisateurs Spring s'y retrouveront également avec une configuration standard Spring MVC et Spring Remoting.
Voici quelques détails de cette configuration :
Seule la configuration de la DispatcherServlet de Spring MVC est nécessaire
L'exposition du MessageBroker de BlazeDS passe par :
la déclaration d'un FactoryBean dans le fichier de configuration XML de Spring MVC : MessageBrokerFactoryBean
le routage des requêtes de la DispatcherServlet vers le MessageBroker via la configuration d'un HandlerMapping
À la manière de Spring Remoting, il ne vous reste plus qu'à exposer vos services Spring au MessageBroker avec la configuration d'un nouveau type d'Exporter : le FlexRemotingServiceExporter
Même si nous n'avons pas encore testé cette solution, cette intégration aussi simple qu'élégante rapproche sans conteste les développeurs Java au développement d'applications Flex.
Choisir sa solution RIA
Les solutions RIA sont de plus en plus nombreuses et il devient difficile de trancher catégoriquement pour l'une ou l'autre lors du démarrage d'un projet. Très souvent, une librairie est choisie par sa côte de popularité alors qu'elle ne correspond pas forcément au besoin client.
Au final, l'énergie dépensée pour apprendre, utiliser et adapter ces widgets/actions/effets dans le projet se révèle très coûteuse en temps, en maintenance...
Robbie Cheng (développeur principal de ZK Mobile pour Android) éclaircit nos esprits avec l'article How to Choose an RIA Solution sur Sys-Con avec un Top 10 des critères architecte et manager à prendre en compte lors du choix de sa solution.
Sans surprise, côté architecte, on se retrouve avec :
de nombreux widgets, simples, des fonctionnalités comme le lazy loading ou le drag & drop, des pop-up...,
facilité de développement,
parfaite intégration dans l'entreprise,
sécurité et scalabilité,
et bien évidemment multiplateforme.
Côté manager, les besoins ne sont pas les mêmes :
solution standard ? utilisée par d'autres projets ? Open Source ?,
bien évidemment le coût de formation, entre une solution JavaScript et Java il n'y a pas qu'un pas ,
outils associés à la solution (plugins, éditeur, WYSIWYG...),
dépendante d'autres librairies / d'autres plugins ?,
un background solide i.e. qui est derrière la solution ! Adobe, Google, un développeur dans son garage ? Mais aussi un support de qualité, des corrections de bugs et des mises à jour régulières.
Selon tous ces aspects, l'auteur nous donne 4 catégories de solutions RIA / frameworks :
Snippet : amélioration légère avec quelques effets, des pages plus rapides à l'affichage, des nouvelles petites fonctions de ci de là... avec peu de changement au niveau de l'architecture ou du design. Script.aculo.us et Prototype sont de bons exemples,
Widget : vous avez dit Web 2.0 ? C'est clairement ce que tout le monde a vu avec l'arrivée de librairies comme YUI ou ExtJS : une nouvelle expérience utilisateur au niveau de l'interface graphique avec des composants travaillés, très beaux, du drag & drop, de l'animation... ces frameworks s'appuient donc sur une libraire de widgets solides,
Client : réécriture de l'application côté client dans une nouvelle technologie, nouvelle interface utilisateur, amélioration de la productivité mais un gros travail de refonte côté client. Nous parlons bien sûr des GWT, Flex et Cie,
Full : la solution complète, riche, MVC, patterns de développement, à la fois une nouvelle expérience utilisateur mais aussi une réelle valeur ajoutée pour l'entreprise... mais nécessite des plateformes/technologies spécifiques côté client et serveur. On citera les ZK ou Wicket.
La conclusion sans surprise à la question (alors, laquelle ???) est bien sûr : ça dépend...
En effet :
tous les projets n'ont pas la même cible d'utilisateur,
et les technologies passent du Java au XML en passant par du JavaScript, autrement dit les compétences ne sont clairement pas les mêmes d'un framework à un autre.
Alors entre jQuery, ExtJS, GWT et Flex, ce sera à vous et vous seul de choisir !
Le coin de la technique
OpenXava 3.1 est disponible
OpenXava est un ensemble d'outils et de composants destinés à simplifier le développement d'applications Web Java.
OpenXava permet de générer des formulaires CRUD à partir des POJOs et des annotations JPA. Il vous propose également d'intégrer des fonctionnalités avancées : la génération des rapports PDF, exports Excel, formulaire de recherche, tri, impression... Avec OX, vous pouvez aussi créer des applications sophistiquées avec une logique complexe et des IHM avancées.
La nouvelle version 3.1 apporte AJAX dans vos applications générées. Pour ceux qui utilisent déjà OX le passage à la version 3.1 permet "d'ajaxifier" vos applications sans toucher une seule ligne de code.
Le projet est fourni sous licence LGPL.
Plusieurs démos sont disponibles.
Java Persistence API 2.0 Public Draft
La spécification JSR 317: JavaTM Persistence 2.0 est un public draft, comme l'annonce sur son blog la specification lead, Linda Demichiel (Sun Microsystems) : Java Persistence 2.0 Public Draft.
Une entrée précédente de la revue de de presse de Xebia : JPA 2.0, la nouvelle version d'une API bien portante, annonçait l'ajout de l'API Criteria à la version 2 de JPA.
Linda Demichiel décrit sur son blog le fonctionnement possible de cette API Criteria : Java Persistence 2.0 Public Draft: Criteria API.
Celle ci permet de construire des requêtes SQL en Java de manière programmatique. Cette technique présente les intérêts suivant :
Les requêtes dynamiques sont plus faciles à construire et leurs constructions peuvent dépendre de données évaluées à l'exécution
Les fonctions des IDE permettent d'assister le développeur comme par exemple le refactoring, la complétion
Cependant les requêtes sont plus difficiles
A optimiser
A maintenir (plus difficile à lire)
Ces requêtes sont construites à partir d'un object QueryDefinition obtenu à partir d'un EntityManager :
EntityManager em = ... ;
QueryBuilder queryBuilder = em.getQueryBuilder();
Exemple de création de requête sur l'entité Customer :
DomainObject customer = queryBuilder.createQueryDefinition(Customer.class);
En manipulant l'objet JPA DomainObject, on peut charger, par jointure, la relation customer->orders->items:
DomainObject item = customer.join("orders").join("items");
Voici un exemple complet :
DomainObject customer = queryBuilder.createQueryDefinition(Customer.class);
DomainObject item = customer.join("orders").join("items");
customer.where(item.get("productType").equal("printer"))
.select(customer.get("name"));
Comme le fait remarquer Gavin King dans l'article A typesafe criteria query API for JPA, il est dommage de manipuler des chaînes de caractères afin d'obtenir un attribut d'une On perd un des intérêts de l'API Criteria : le refactoring et la complétion fournis par les IDE.
Ainsi, en reprenant l'exemple complet, si l'on renomme l'attribut name de la customer en firstName (avec notre IDE préféré), notre IDE sera incapable de changer le requête précédente de customer.get("name") à customer.get("firstName").
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/Vh85iJtzq5o/
La sortie de Native Client, une technologie encore expérimentale du Google Labs, est passée complètement inaperçue à quelques rares billets près. Le problème n’est pas que les blogueurs soient peu inspirés par cette nouvelle, mais plutôt que ce produit a tellement été mal présenté au public que personne ne sait trop à quoi ça va servir. Pour information il m’a fallu près de deux semaines de cogitation avant d’attaquer la rédaction de ce billet.
Pas réellement un concurrent de Flash ou de AIR
Force est de constater que ce nouveau produit est plutôt obscur, que les explications sont rares et que même les équipes à l’origine de ce projet sont incapables de fournir une explication claire (cf. Native Client: An OS in Your Browser). Pour faire simple, Native Client est une extension que vous installez sur votre ordinateur pour pouvoir exécuter au travers de votre navigateur des applications en ligne écrites en code natif (C ou C++). Si vous avez le courage vous pouvez toujours lire l’annonce officielle mais vous n’y apprendrez pas grand chose de plus : Native Client, A Technology for Running Native Code on the Web.
Ne vous y trompez pas, même s’il est beaucoup question de RIA, NaCl n’est ni un plugin à la
Flash ou
Silverlight, ni un runtime à la
AIR . Ce n’est pas non plus une technologie qui exploite une machine virtuelle à la JavaFX et pour finir c’est encore moins un mini-système d’exploitation. En fait c’est un peu tout ça à la fois (bien que pas tout à fait). Lire à ce sujet : Why Google Native Client is not a Flash competitor.
En tout cas le moins que l’on puisse dire c’est que Native Client laisse un certain nombre d’observateurs avertis très sceptiques : Google Native Client: A Game Changer or an Also-Ran? et Google Native Client: web deluxe, or ActiveX redux?.
Avec Native Client ne gaspillez plus la ressource de votre processeur
Pour bien comprendre tout l’intérêt de Native Client (NaCl pour les intimes), il faut se pencher sur l’architecture des ordinateurs et surtout sur le fonctionnement des plug-in. Pour faire simple un ordinateur est composé de couches matérielles (la carte mère, le processeur, la carte graphique…) et de couches logiciels (le système d’exploitation, les applications…). Quand vous consultez une interface riche en Flash, celle-ci repose sur du code qui est interprété par le plug-in, par le navigateur, par le système d’exploitation et finalement par le processeur. Ce dernier traite l’instruction et remonte un résultat dans l’autre sens. Toutes ces couches sont autant d’intermédiaires qui traduisent, interprêtent et ne font que vous gaspiller de la ressource (mémoire et puissance de calcul). Voilà pourquoi les animations 3D exécutées dans Flash vous paraissent minables comparé à ce que votre carte graphique est capable de faire.
Avec Native Client, la promesse est de ne plus gaspiller cette ressource en évitant les intermédiaires (les différentes couches logicielles) et de faire en sorte que les applications en ligne exécutées dans votre navigateur ne soient que 1% moins lentes que celles qui sont installées sur le système d’exploitation. Lire à ce sujet l’excellent mais très technique article de Samy : Avec Native Client, Google invente l’ OS dans le navigateur.
Si la promesse est belle (des performances sans commune mesure) et l’exploit technologie réel, il y a une contre-partie : les applications en ligne doivent être développées en C ou C++. Et c’est là où ça coince : le C et le C++ sont des langages de programmation contraignants qui ne sont pas réellement adaptés aux interfaces riches. Il existe maintenant de nouveaux langages beaucoup plus sophistiqués qui se sont imposés sur ce créneau avec des environnement de développement dédiés beaucoup plus productifs (à l’image d’
Eclipse ou de Flex Builder). Donc concrètement pour bénéficier des performances de NaCl il faut revenir 20 ans en arrière et se réapproprier des langages qui font dramatiquement chuter la productivité. En clair il va vous falloir beaucoup plus de temps pour développer la même application. Tout ça pour quoi ? Pour de meilleures performances, mais est-ce que la performance est réellement un problème ?
PS : Ceci est une tentative naïve de l’auteur d’expliquer de façon simple le fonctionnement des ordinateurs pour pouvoir mieux comprendre la prise de position sur NaCl. Les premières versions de cette explication étaient approximatives et ont engendrés des commentaires très aggréssifs qui ont polués la discussion avec un débat de forme (”le C n’est pas mort et il est plus performant que Java”) au détriment d’une discussion de fond (NaCl est une belle avancée technologique mais qui ne trouvera pas forcément son public dans la mesure où les usages de l’outil informatique sont amenés à beaucoup changés dans les prochaine années, notamment avec les approches centrées sur la collaboration de l’Entreprise 2.0).
Le faux débat de la performance
Oui, la performance est importante, car il en faut pour faire tourner dans votre navigateur des applications équivalentes à ce que vous avez sur votre disque dur. Mais d’un autre côté est-ce que c’est un but légitime ? Traduction : Quel est l’intérêt de faire tourner Word 2007 dans votre navigateur quand un wiki peut vous apporter un bien meilleur service ? Quel est l’intérêt de faire tourner un mastodonte comme Photoshop dans votre navigateur alors que dans 90% des cas vous pouvez vous suffir de Photoshop Express ou de Picnick ?
Nous entrons ici dans la partie délicate de la discussion autour de NaCl, la partie où l’on va se rendre compte que cette technologie est surtout révolutionnaire pour les éditeurs de logiciels, pas pour les concepteurs d’interfaces riches. L’industrie du logiciel est en effet en train de se scinder en deux clans : d’un côté les applications lourdes (Photoshop, 3DSMax…) qui sont avant tout destinées à un petit nombre de professionnels spécialisés dans un domaine et nécessitant beaucoup de ressources (mémoire, puissance de calcul, capacité de stockage…), de l’autre des applications plus légères (
SalesForce, Basecamp…) qui sont avant tout orientées collaboration et qui consomment très peu de ressources. Le modèle SaaS est donc parfaitement adapté à la seconde catégorie avec des technologies parfaitement maîtrisées ( HTML + Javascript, Flash…) qui ne posent pas de problème de performance.
Vous pourriez me dire que le débat sur la performance est revenu sur le devant de la scène avec la mode des ordinateurs low cost (les EeePC et autres netbooks) qui ne disposent pas du tout de la même puissance de calcul. Pour ce segment bien particulier il serait intéressant de voir s’il est rentable d’adapter des applications desktop existantes pour les reformater aux contraintes de ces ordinateurs (petit écran…). Mais encore une fois la solution se trouve plutôt dans une nouvelle approche de l’outil informatique (avec les intranets wikifiés et les mashups d’entreprise) plutôt que dans l’exploit technique de faire tourner Office 2007 et Vista sur un EeePC.
Ceci est d’autant plus vrai que les dernières versions de navigateurs comme
Firefox,
Opera ou
Chrome ont fait un bond spectaculaire et ont réussi à décupler les performances d’exécution de code Javascript. Et comme une bonne nouvelle ne vient jamais seule, les plug-in progressent aussi à pas de géant puisque Flash 11 et Silverlight 3 devront également marquer une nette rupture de performance avec une prise en charge beaucoup plus poussée de l’accélération matériel, donc un recours plus intensif aux composants hardware (notamment la carte graphique) et moins de gaspillage de mémoire. Ca ne vous rappelle rien ? Bref, toutes ces améliorations à venir nous font relativiser le gain de performance annoncé par NaCl. Mais bon… l’idée n’est pas neuve car Microsoft avait tenté d’introduire une technologie équivalente avec les fameux ActvieX (cf. Google Native Client : Un ActiveX-Like ?) et n’oublions pas non plus que le javascript a ses limites (cf. L’invasion des machines virtuelles).
Donc au final NaCl doit être avant tout considéré comme un environnement d’exécution et de déploiement révolutionnaire car il permet aux éditeurs de ne développer qu’une seule version de leurs applications et de les distribuer via le web (en évitant les circuits de distribution avec boîtes et DVD ). Vous noterez au passage que cette solution n’a été rendu viable que depuis l’adoption d’une architecture commune (x86) par les constructeurs et éditeurs de système d’exploitation (Microsoft / Windows, Apple / Mac OSX, Linux). Pour en savoir plus sur le potentiel de NaCl dans ce domaine je vous recommande cet article de Louis Naugès : Web 2.0, Lla marginalisation, définitive, de Windows sur les PC .
C’est quoi déjà une interface riche ?
Mais revenons à nos moutons : les interfaces riches. Dans la vision de Google, les interfaces riches sont avant tout destinées à être exploitées dans le cadre d’applications en ligne. Mais cette vision est très réductrice car que fait-on des innombrables interfaces riches qui reposent sur de la vidéo, des animations, du son, des transitions et autres effets spéciaux ?
Même si Native Client intègre un moteur de rendu vectoriel, Flash (et dans une certaine mesure Silverlight) reste la technologie la plus appropriée et de très loin pour faire ce type d’interface. Est-ce que vous vous imaginez faire un carrousel, un configurateur ou un assistant au choix en C ou C++ ? Non bien évidement car ce n’est pas pour cela que ces langages ont été conçus. L’avantage de Flash est d’autant plus net qu’il est couplé avec un environnement de production parfaitement adapté à ce type d’interface ainsi qu’une infinité de bibliothèques prêtes à l’emploi pour gagner du temps. Vous noterez que l’approche de Google centrée sur les applications en ligne se vérifie également avec d’autres produits comme GWT, un framework Ajax qui est exclusivement tourné vers une logique applicative.
Bref, ce n’est pas demain que nous allons voir des studios de production comme 2advanced, Blitz, Megalos ou Soleil Noir abandonner Flash pour faire du C. Ces studios sont capables de faire des prouesses que le C n’autorise pas.
Conclusion
Si nous résumons :
NaCl n’est pas un plug-in, c’est un projet encore expérimental qui n’est même pas en phase alpha ;
NaCl n’est pas un mini-système d’exploitation, c’est un complément qui permet de court-circuiter des intermédiaires pour profiter des pleines performances du matériel ;
NaCl n’est pas concurrent de Flash ou Silverlight qui sont bien plus performants pour faire de belles interfaces riches ;
NaCl dépend de langages de programmation (C et C++) qui sont plus plus performant mais plus contraignant ;
NaCl propose une approche tout à fait intéressante de la distribution de logiciels, mais les gros éditeurs disposent de leviers très puissants (accords cadres, partenariats, lobbying…) pour défendre leur modèle de distribution (et je ne parle pas que de Microsoft).
Voilà pourquoi NaCl va très certainement chambouler la longue traîne de l’industrie logiciel bien que cette technologie ne soit en l’état pas viable pour survivre sur le marché des RIA. Marché déjà bien encombré avec Flash, Silverlight, JavaFX ou des acteurs de niche comme Curl ou Unity3D (respectivement pour des applications en ligne d’entreprise et pour des jeux en 3D comme Cmune).
Reste donc deux possibilités : Soit Google fait fortement évoluer son produit pour le rendre réellement attractif (en expliquant clairement ce à quoi il sert et ce qu’il n’est pas), soit NaCl restera une expérimentation intéressante mais qui sera confinée à un usage interne chez Google.
http://feedproxy.google.com/~r/fredcavazza/~3/Hc1L-9jSt9g/
La sortie de Native Client, une technologie encore expérimentale du Google Labs, est passée complètement inaperçue à quelques rares billets près. Le problème n’est pas que les blogueurs soient peu inspirés par cette nouvelle, mais plutôt que ce produit a tellement été mal présenté au public que personne ne sait trop à quoi ça va servir. Pour information il m’a fallu près de deux semaines de cogitation avant d’attaquer la rédaction de ce billet.
Pas réellement un concurrent de Flash ou de AIR
Force est de constater que ce nouveau produit est plutôt obscur, que les explications sont rares et que même les équipes à l’origine de ce projet sont incapables de fournir une explication claire (cf. Native Client: An OS in Your Browser). Pour faire simple, Native Client est une extension que vous installez sur votre ordinateur pour pouvoir exécuter au travers de votre navigateur des applications en ligne écrites en code natif (C ou C++). Si vous avez le courage vous pouvez toujours lire l’annonce officielle mais vous n’y apprendrez pas grand chose de plus : Native Client, A Technology for Running Native Code on the Web.
Ne vous y trompez pas, même s’il est beaucoup question de RIA, NaCl n’est ni un plugin à la
Flash ou
Silverlight, ni un runtime à la
AIR . Ce n’est pas non plus une technologie qui exploite une machine virtuelle à la JavaFX et pour finir c’est encore moins un mini-système d’exploitation. En fait c’est un peu tout ça à la fois (bien que pas tout à fait). Lire à ce sujet : Why Google Native Client is not a Flash competitor.
En tout cas le moins que l’on puisse dire c’est que Native Client laisse un certain nombre d’observateurs avertis très sceptiques : Google Native Client: A Game Changer or an Also-Ran? et Google Native Client: web deluxe, or ActiveX redux?.
Avec Native Client ne gaspillez plus la ressource de votre processeur
Pour bien comprendre tout l’intérêt de Native Client (NaCl pour les intimes), il faut se pencher sur l’architecture des ordinateurs et surtout sur le fonctionnement des plug-in. Pour faire simple un ordinateur est composé de couches matérielles (la carte mère, le processeur, la carte graphique…) et de couches logiciels (le système d’exploitation, les applications…). Quand vous consultez une interface riche en Flash, celle-ci repose sur du code qui est interprété par le plug-in, par le navigateur, par le système d’exploitation et finalement par le processeur. Ce dernier traite l’instruction et remonte un résultat dans l’autre sens. Toutes ces couches sont autant d’intermédiaires qui traduisent, interprêtent et ne font que vous gaspiller de la ressource (mémoire et puissance de calcul). Voilà pourquoi les animations 3D exécutées dans Flash vous paraissent minables comparé à ce que votre carte graphique est capable de faire.
Avec Native Client, la promesse est de ne plus gaspiller cette ressource en évitant les intermédiaires (les différentes couches logicielles) et de faire en sorte que les applications en ligne exécutées dans votre navigateur ne soient que 1% moins lentes que celles qui sont installées sur le système d’exploitation. Lire à ce sujet l’excellent mais très technique article de Samy : Avec Native Client, Google invente l’ OS dans le navigateur.
Si la promesse est belle (des performances sans commune mesure) et l’exploit technologie réel, il y a une contre-partie : les applications en ligne doivent être développées en C ou C++. Et c’est là où ça coince : le C et le C++ sont des langages de programmation contraignants qui ne sont pas réellement adaptés aux interfaces riches. Il existe maintenant de nouveaux langages beaucoup plus sophistiqués qui se sont imposés sur ce créneau avec des environnement de développement dédiés beaucoup plus productifs (à l’image d’
Eclipse ou de Flex Builder). Donc concrètement pour bénéficier des performances de NaCl il faut revenir 20 ans en arrière et se réapproprier des langages qui font dramatiquement chuter la productivité. En clair il va vous falloir beaucoup plus de temps pour développer la même application. Tout ça pour quoi ? Pour de meilleures performances, mais est-ce que la performance est réellement un problème ?
PS : Ceci est une tentative naïve de l’auteur d’expliquer de façon simple le fonctionnement des ordinateurs pour pouvoir mieux comprendre la prise de position sur NaCl. Les premières versions de cette explication étaient approximatives et ont engendrés des commentaires très aggréssifs qui ont polués la discussion avec un débat de forme (”le C n’est pas mort et il est plus performant que Java”) au détriment d’une discussion de fond (NaCl est une belle avancée technologique mais qui ne trouvera pas forcément son public dans la mesure où les usages de l’outil informatique sont amenés à beaucoup changés dans les prochaine années, notamment avec les approches centrées sur la collaboration de l’Entreprise 2.0).
Le faux débat de la performance
Oui, la performance est importante, car il en faut pour faire tourner dans votre navigateur des applications équivalentes à ce que vous avez sur votre disque dur. Mais d’un autre côté est-ce que c’est un but légitime ? Traduction : Quel est l’intérêt de faire tourner Word 2007 dans votre navigateur quand un wiki peut vous apporter un bien meilleur service ? Quel est l’intérêt de faire tourner un mastodonte comme Photoshop dans votre navigateur alors que dans 90% des cas vous pouvez vous suffir de Photoshop Express ou de Picnick ?
Nous entrons ici dans la partie délicate de la discussion autour de NaCl, la partie où l’on va se rendre compte que cette technologie est surtout révolutionnaire pour les éditeurs de logiciels, pas pour les concepteurs d’interfaces riches. L’industrie du logiciel est en effet en train de se scinder en deux clans : d’un côté les applications lourdes (Photoshop, 3DSMax…) qui sont avant tout destinées à un petit nombre de professionnels spécialisés dans un domaine et nécessitant beaucoup de ressources (mémoire, puissance de calcul, capacité de stockage…), de l’autre des applications plus légères (
SalesForce, Basecamp…) qui sont avant tout orientées collaboration et qui consomment très peu de ressources. Le modèle SaaS est donc parfaitement adapté à la seconde catégorie avec des technologies parfaitement maîtrisées ( HTML + Javascript, Flash…) qui ne posent pas de problème de performance.
Vous pourriez me dire que le débat sur la performance est revenu sur le devant de la scène avec la mode des ordinateurs low cost (les EeePC et autres netbooks) qui ne disposent pas du tout de la même puissance de calcul. Pour ce segment bien particulier il serait intéressant de voir s’il est rentable d’adapter des applications desktop existantes pour les reformater aux contraintes de ces ordinateurs (petit écran…). Mais encore une fois la solution se trouve plutôt dans une nouvelle approche de l’outil informatique (avec les intranets wikifiés et les mashups d’entreprise) plutôt que dans l’exploit technique de faire tourner Office 2007 et Vista sur un EeePC.
Ceci est d’autant plus vrai que les dernières versions de navigateurs comme
Firefox,
Opera ou
Chrome ont fait un bond spectaculaire et ont réussi à décupler les performances d’exécution de code Javascript. Et comme une bonne nouvelle ne vient jamais seule, les plug-in progressent aussi à pas de géant puisque Flash 11 et Silverlight 3 devront également marquer une nette rupture de performance avec une prise en charge beaucoup plus poussée de l’accélération matériel, donc un recours plus intensif aux composants hardware (notamment la carte graphique) et moins de gaspillage de mémoire. Ca ne vous rappelle rien ? Bref, toutes ces améliorations à venir nous font relativiser le gain de performance annoncé par NaCl. Mais bon… l’idée n’est pas neuve car Microsoft avait tenté d’introduire une technologie équivalente avec les fameux ActvieX (cf. Google Native Client : Un ActiveX-Like ?) et n’oublions pas non plus que le javascript a ses limites (cf. L’invasion des machines virtuelles).
Donc au final NaCl doit être avant tout considéré comme un environnement d’exécution et de déploiement révolutionnaire car il permet aux éditeurs de ne développer qu’une seule version de leurs applications et de les distribuer via le web (en évitant les circuits de distribution avec boîtes et DVD ). Vous noterez au passage que cette solution n’a été rendu viable que depuis l’adoption d’une architecture commune (x86) par les constructeurs et éditeurs de système d’exploitation (Microsoft / Windows, Apple / Mac OSX, Linux). Pour en savoir plus sur le potentiel de NaCl dans ce domaine je vous recommande cet article de Louis Naugès : Web 2.0, Lla marginalisation, définitive, de Windows sur les PC .
C’est quoi déjà une interface riche ?
Mais revenons à nos moutons : les interfaces riches. Dans la vision de Google, les interfaces riches sont avant tout destinées à être exploitées dans le cadre d’applications en ligne. Mais cette vision est très réductrice car que fait-on des innombrables interfaces riches qui reposent sur de la vidéo, des animations, du son, des transitions et autres effets spéciaux ?
Même si Native Client intègre un moteur de rendu vectoriel, Flash (et dans une certaine mesure Silverlight) reste la technologie la plus appropriée et de très loin pour faire ce type d’interface. Est-ce que vous vous imaginez faire un carrousel, un configurateur ou un assistant au choix en C ou C++ ? Non bien évidement car ce n’est pas pour cela que ces langages ont été conçus. L’avantage de Flash est d’autant plus net qu’il est couplé avec un environnement de production parfaitement adapté à ce type d’interface ainsi qu’une infinité de bibliothèques prêtes à l’emploi pour gagner du temps. Vous noterez que l’approche de Google centrée sur les applications en ligne se vérifie également avec d’autres produits comme GWT, un framework Ajax qui est exclusivement tourné vers une logique applicative.
Bref, ce n’est pas demain que nous allons voir des studios de production comme 2advanced, Blitz, Megalos ou Soleil Noir abandonner Flash pour faire du C. Ces studios sont capables de faire des prouesses que le C n’autorise pas.
Conclusion
Si nous résumons :
NaCl n’est pas un plug-in, c’est un projet encore expérimental qui n’est même pas en phase alpha ;
NaCl n’est pas un mini-système d’exploitation, c’est un complément qui permet de court-circuiter des intermédiaires pour profiter des pleines performances du matériel ;
NaCl n’est pas concurrent de Flash ou Silverlight qui sont bien plus performants pour faire de belles interfaces riches ;
NaCl dépend de langages de programmation (C et C++) qui sont plus plus performant mais plus contraignant ;
NaCl propose une approche tout à fait intéressante de la distribution de logiciels, mais les gros éditeurs disposent de leviers très puissants (accords cadres, partenariats, lobbying…) pour défendre leur modèle de distribution (et je ne parle pas que de Microsoft).
Voilà pourquoi NaCl va très certainement chambouler la longue traîne de l’industrie logiciel bien que cette technologie ne soit en l’état pas viable pour survivre sur le marché des RIA. Marché déjà bien encombré avec Flash, Silverlight, JavaFX ou des acteurs de niche comme Curl ou Unity3D (respectivement pour des applications en ligne d’entreprise et pour des jeux en 3D comme Cmune).
Reste donc deux possibilités : Soit Google fait fortement évoluer son produit pour le rendre réellement attractif (en expliquant clairement ce à quoi il sert et ce qu’il n’est pas), soit NaCl restera une expérimentation intéressante mais qui sera confinée à un usage interne chez Google.
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/BxOwuyldxLU/
La sortie de Native Client, une technologie encore expérimentale du Google Labs, est passée complètement inaperçue à quelques rares billets près. Le problème n’est pas que les blogueurs soient peu inspirés par cette nouvelle, mais plutôt que ce produit a tellement été mal présenté au public que personne ne sait trop à quoi ça va servir. Pour information il m’a fallu près de deux semaines de cogitation avant d’attaquer la rédaction de ce billet.
Pas réellement un concurrent de Flash ou de AIR
Force est de constater que ce nouveau produit est plutôt obscur, que les explications sont rares et que même les équipes à l’origine de ce projet sont incapables de fournir une explication claire (cf. Native Client: An OS in Your Browser). Pour faire simple, Native Client est une extension que vous installez sur votre ordinateur pour pouvoir exécuter au travers de votre navigateur des applications en ligne écrites en code natif (C ou C++). Si vous avez le courage vous pouvez toujours lire l’annonce officielle mais vous n’y apprendrez pas grand chose de plus : Native Client, A Technology for Running Native Code on the Web.
Ne vous y trompez pas, même s’il est beaucoup question de RIA, NaCl n’est ni un plugin à la
Flash ou
Silverlight, ni un runtime à la
AIR . Ce n’est pas non plus une technologie qui exploite une machine virtuelle à la JavaFX et pour finir c’est encore moins un mini-système d’exploitation. En fait c’est un peu tout ça à la fois (bien que pas tout à fait). Lire à ce sujet : Why Google Native Client is not a Flash competitor.
En tout cas le moins que l’on puisse dire c’est que Native Client laisse un certain nombre d’observateurs avertis très sceptiques : Google Native Client: A Game Changer or an Also-Ran? et Google Native Client: web deluxe, or ActiveX redux?.
Avec Native Client ne gaspillez plus la ressource de votre processeur
Pour bien comprendre tout l’intérêt de Native Client (NaCl pour les intimes), il faut se pencher sur l’architecture des ordinateurs et surtout sur le fonctionnement des plug-in. Pour faire simple un ordinateur est composé de couches matérielles (la carte mère, le processeur, la carte graphique…) et de couches logiciels (le système d’exploitation, les applications…). Quand vous consultez une interface riche en Flash, celle-ci repose sur du code qui est interprété par le plug-in, par le navigateur, par le système d’exploitation et finalement par le processeur. Ce dernier traite l’instruction et remonte un résultat dans l’autre sens. Toutes ces couches sont autant d’intermédiaires qui traduisent, interprêtent et ne font que vous gaspiller de la ressource (mémoire et puissance de calcul). Voilà pourquoi les animations 3D exécutées dans Flash vous paraissent minables comparé à ce que votre carte graphique est capable de faire.
Avec Native Client, la promesse est de ne plus gaspiller cette ressource en évitant les intermédiaires (les différentes couches logicielles) et de faire en sorte que les applications en ligne exécutées dans votre navigateur ne soient que 1% moins lentes que celles qui sont installées sur le système d’exploitation. Lire à ce sujet l’excellent mais très technique article de Samy : Avec Native Client, Google invente l’ OS dans le navigateur.
Si la promesse est belle (des performances sans commune mesure) et l’exploit technologie réel, il y a une contre-partie : les applications en ligne doivent être développées en C ou C++. Et c’est là où ça coince : le C et le C++ sont des langages de programmation “bas niveau” qui ne sont pas réellement adaptés aux interfaces riches. Il existe maintenant de nouveaux langages beaucoup plus sophistiqués qui se sont imposés sur ce créneau avec des environnement de développement beaucoup plus productifs (à l’image d’
Eclipse ou de Flex Builder). Donc concrètement pour bénéficier des performances de NaCl il faut revenir 20 ans en arrière et se réapproprier des langages qui font dramatiquement chuter la productivité. En clair il va vous falloir beaucoup plus de temps pour développer la même application. Tout ça pour quoi ? Pour de meilleures performances, mais est-ce que la performance est réellement un problème ?
Le faux débat de la performance
Oui, la performance est importante, car il en faut pour faire tourner dans votre navigateur des applications équivalentes à ce que vous avez sur votre disque dur. Mais d’un autre côté est-ce que c’est un but légitime ? Traduction : Quel est l’intérêt de faire tourner Word 2007 dans votre navigateur quand un wiki peut vous apporter un bien meilleur service ? Quel est l’intérêt de faire tourner un mastodonte comme Photoshop dans votre navigateur alors que dans 90% des cas vous pouvez vous suffir de Photoshop Express ou de Picnick ?
Nous entrons ici dans la partie délicate de la discussion autour de NaCl, la partie où l’on va se rendre compte que cette technologie est surtout révolutionnaire pour les éditeurs de logiciels, pas pour les concepteurs d’interfaces riches. L’industrie du logiciel est en effet en train de se scinder en deux clans : d’un côté les applications lourdes (Photoshop, 3DSMax…) qui sont avant tout destinées à un petit nombre de professionnels spécialisés dans un domaine et nécessitant beaucoup de ressources (mémoire, puissance de calcul, capacité de stockage…), de l’autre des applications plus légères (
SalesForce, Basecamp…) qui sont avant tout orientées collaboration et qui consomment très peu de ressources. Le modèle SaaS est donc parfaitement adapté à la seconde catégorie avec des technologies parfaitement maîtrisées ( HTML + Javascript, Flash…) qui ne posent pas de problème de performance.
Vous pourriez me dire que le débat sur la performance est revenu sur le devant de la scène avec la mode des ordinateurs low cost (les EeePC et autres netbooks) qui ne disposent pas du tout de la même puissance de calcul. Pour ce segment bien particulier il serait intéressant de voir s’il est rentable d’adapter des applications desktop existantes pour les reformater aux contraintes de ces ordinateurs (petit écran…). Mais encore une fois la solution se trouve plutôt dans une nouvelle approche de l’outil informatique (avec les intranets wikifiés et les mashups d’entreprise) plutôt que dans l’exploit technique de faire tourner Office 2007 et Vista sur un EeePC.
Ceci est d’autant plus vrai que les dernières versions de navigateurs comme
Firefox,
Opera ou
Chrome ont fait un bond spectaculaire et ont réussi à décupler les performances d’exécution de code Javascript. Et comme une bonne nouvelle ne vient jamais seule, les plug-in progressent aussi à pas de géant puisque Flash 11 et Silverlight 3 devront également marquer une nette rupture de performance avec une prise en charge beaucoup plus poussée de l’accélération matériel, donc un recours plus intensif aux composants hardware (notamment la carte graphique) et moins de gaspillage de mémoire. Ca ne vous rappelle rien ? Bref, toutes ces améliorations à venir nous font relativiser le gain de performance annoncé par NaCl. Mais bon… l’idée n’est pas neuve car Microsoft avait tenté d’introduire une technologie équivalente avec les fameux ActvieX (cf. Google Native Client : Un ActiveX-Like ?) et n’oublions pas non plus que le javascript a ses limites (cf. L’invasion des machines virtuelles).
Donc au final NaCl doit être avant tout considéré comme un environnement d’exécution et de déploiement révolutionnaire car il permet aux éditeurs de ne développer qu’une seule version de leurs applications et de les distribuer via le web (en évitant les circuits de distribution avec boîtes et DVD ). Vous noterez au passage que cette solution n’a été rendu viable que depuis l’adoption d’une architecture commune (x86) par les constructeurs et éditeurs de système d’exploitation (Microsoft / Windows, Apple / Mac OSX, Linux). Pour en savoir plus sur le potentiel de NaCl dans ce domaine je vous recommande cet article de Louis Naugès : Web 2.0, Lla marginalisation, définitive, de Windows sur les PC .
C’est quoi déjà une interface riche ?
Mais revenons à nos moutons : les interfaces riches. Dans la vision de Google, les interfaces riches sont avant tout destinées à être exploitées dans le cadre d’applications en ligne. Mais cette vision est très réductrice car que fait-on des innombrables interfaces riches qui reposent sur de la vidéo, des animations, du son, des transitions et autres effets spéciaux ?
Même si Native Client intègre un moteur de rendu vectoriel, Flash (et dans une certaine mesure Silverlight) reste la technologie la plus appropriée et de très loin pour faire ce type d’interface. Est-ce que vous vous imaginez faire un carrousel, un configurateur ou un assistant au choix en C ou C++ ? Non bien évidement car ce n’est pas pour cela que ces langages ont été conçus. L’avantage de Flash est d’autant plus net qu’il est couplé avec un environnement de production parfaitement adapté à ce type d’interface ainsi qu’une infinité de bibliothèques prêtes à l’emploi pour gagner du temps. Vous noterez que l’approche de Google centrée sur les applications en ligne se vérifie également avec d’autres produits comme GWT, un framework Ajax qui est exclusivement tourné vers une logique applicative.
Bref, ce n’est pas demain que nous allons voir des studios de production comme 2advanced, Blitz, Megalos ou Soleil Noir abandonner Flash pour faire du C. Ces studios sont capables de faire des prouesses que le C n’autorise pas.
Conclusion
Si nous résumons :
NaCl n’est pas un plug-in, c’est un projet encore expérimental qui n’est même pas en phase alpha ;
NaCl n’est pas un mini-système d’exploitation, c’est un complément qui permet de court-circuiter des intermédiaires pour profiter des pleines performances du matériel ;
NaCl n’est pas concurrent de Flash ou Silverlight qui sont bien plus performants pour faire de belles interfaces riches ;
NaCl dépend de langages de programmation (C et C++) qui sont plus plus performant mais plus contraignant ;
NaCl propose une approche tout à fait intéressante de la distribution de logiciels, mais les gros éditeurs disposent de leviers très puissants (accords cadres, partenariats, lobbying…) pour défendre leur modèle de distribution (et je ne parle pas que de Microsoft).
Voilà pourquoi NaCl va très certainement chambouler la longue traîne de l’industrie logiciel bien que cette technologie ne soit en l’état pas viable pour survivre sur le marché des RIA. Marché déjà bien encombré avec Flash, Silverlight, JavaFX ou des acteurs de niche comme Curl ou Unity3D (respectivement pour des applications en ligne d’entreprise et pour des jeux en 3D comme Cmune).
Reste donc deux possibilités : Soit Google fait fortement évoluer son produit pour le rendre réellement attractif (en expliquant clairement ce à quoi il sert et ce qu’il n’est pas), soit NaCl restera une expérimentation intéressante mais qui sera confinée à un usage interne chez Google.
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/492399542/
Le langage PHP et le langage Java sont deux langages différents.
Luke Welling explique dans le calendrier de PHP Advent 2008, pourquoi PHP est si différent du langage Java et qu'il n'est pas nécessaire de refaire la même chose ou technique pour arriver au même résultat.
Il prend même le temps de vous expliquer la phrase française « Il pleut des cordes » qui peut avoir plusieurs significations, dans des langues différentes. PHP Is Not Java (0 visite)
http://feedproxy.google.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/mGljJ2RQwVA/18872-php_nest_pas_java.php
Le langage PHP et le langage Java sont deux langages différents.
Luke Welling explique dans le calendrier de PHP Advent 2008, pourquoi PHP est si différent du langage Java et qu'il n'est pas nécessaire de refaire la même chose ou technique pour arriver au même résultat.
Il prend même le temps de vous expliquer la phrase française « Il pleut des cordes » qui peut avoir plusieurs significations, dans des langues différentes. PHP Is Not Java (0 visite)
http://feeds.feedburner.com/~r/SolucomGroup/Dreamsoft/APP/Veille/~3/508594159/18872-php_nest_pas_java.php
Update Sources