Les partitions gratuites de Marc Lambert pour guitare

Marc Lambert  publie 90 Partitions gratuites pour guitare, toutes classées par niveau de difficulté.
"Marc sa guitare" accessible sur guitare.org publie aussi des partitions pour groupe de trois ou quatre guitares.

En guise d'exemple, voici une interprétation  de la "Valse Bleue" de Marc Lambert.
Simplement magnifique!

Utilisation des blogs pour consolider les connaissances d'entreprise

L'utilisation et la tenue d'un blog est souvent considéré comme une perte de temps par le monde du travail.
Dans le cadre professionnel, il existe cependant une utilisation rentable de ces blogs
 

L'avis personnel
L'expérience de cette dernière année avec "Developer Notepad" (ce blog) a été professionnellement payant plus d'une fois. Une simple recherche Google fournissant une réponse aux questions déjà abordées et élucidées.
L'utilisation d'un blog de type professionnel pour organiser et maintenir des connaissances techniques est devenu pour moi une évidence en soi.
A mes yeux, le retour sur investissement (le temps nécessaire à la rédaction) ne fait plus de doute et est parfaitement démontrable.
Je dois avouer que mon expérience recoupe parfaitement les conclusions exposées dans l'article de Jean-Luc Tholozan (voir "un retour d'expérience" ci-dessous).
Article que je vous invite par ailleurs à parcourir.


Un retour d'expérience
Allant plus loin dans l'étude d'utilisation d'un Blog, Jean-Luc Tholozan a écrit l'article "Entreprise 2.0 : Blogging en R&D, Un retour d'expérience".
Dans ce dernier, il partage son expérience et ses conclusions sur l'utilisation des technologies WEB 2.0 (et donc aussi les blogs) "dans le cadre d'une étude sur l'utilisation de ces technologies à la gestion des connaissances dans le monde de l'entreprise" (dixit Jean-Luc Tholozan).

Cet article très bien construit démontre l'utilité, la pertinence et les avantages de l'utilisation d'un Blog publique dans un service de Recherche et Développement.
J'ai également été impressionné par l'approche concernant la pérénité et la consolidation des informations acquises par le service de R&D de son entreprise.

Voici un extrait de de l'article "Entreprise 2.0 : Blogging en R&D, Un retour d'expérience" publié sur Architecture des S.I.

Une seconde raison de l'utilisation du Blog est qu'il correspond bien à la problématique de publication d'une équipe de R&D : les phases de recherche s'appuient sur des études bibliographiques importantes. On a très vite tendance à lire et oublier pour passer rapidement à l'étape suivante. Les étapes intermédiaires disparaissent plus ou moins rapidement de la mémoire du chercheur, mais n'entre jamais dans le patrimoine de connaissance de l'entreprise. La publication sous forme de Blog permet d'alterner les phases de lectures et celles de publications : ces dernières permettent à la fois la consolidation des connaissances de l'individu chercheur mais également la consolidation des connaissances dans l'entreprise.

Avec ses conclusions

La création de Blog personnel pour une équipe de R&D s'avère très rentable pour l'entreprise :

• le suivi de la R&D est facilité
• la productivité n'est pas pénalisée : l'effort supplémentaire est compensé par les gains qui suivent
• le patrimoine de connaissance de l'entreprise est consolidé

Un article de grande qualité et pertinent.
Un incontournable à lire!

Sources:

• L'article "Entreprise 2.0 : Blogging en R&D, Un retour d'expérience" publié sur Architecture des S.I.
• L'article "Windows Live Writer et Blogger"
• L'article "Pourquoi utiliser Blogger ? Un retour d'expérience"
• Le blog Architecture des S.I
  

Isodore de Séville, le saint patron des informaticiens

Fêté le 4 avril, Isodore de Séville à été proposé comme Saint patron des informaticiens (des utilisateurs d'ordinateurs et d'internet par extension).

Ce qui vaut à Saint Isidore de devenir notre potentiel Saint patron, c'est la création et l'organisation d'un bestiaire médiévale pour l'un des 26 volumes constituant son oeuvre relative à l'étymologique.
En agissant de la sorte, Isodore fût un précurseur en créant une table des matières qui sert à l'indexation du contenu (du moins assimilé comme). Ces mêmes indexes, ordonnancements alphabétiques, que l'univers de l'information (et donc les informaticiens) utilise à outrance.

Isidore de Séville, né entre 560 et 570 à Carthagène (Espagne) – mort le 4 avril 636, est un religieux espagnol du VIIe siècle. Il a été canonisé en 1598 et est fêté chaque année le 4 avril (Isidore de Séville sur Wikipédia).

Bref, lors du prochain plantage ou bug, je saurai enfin quel Saint invoquer :-)

Un meilleur éditeur pour Blogger

Petite mise-à-jour ce 22 décembre pour référencer "Windows Live Writer" et "ScribeFire" 

Blogger dispose d'une interface d'édition nettement plus efficace et conviviale que l'interface actuelle.
Cette nouvelle interface est accessible via le site "laboratoire" draft.blogger.com .
Je dois reconnaître que c'est une version vraiment pratique et surtout stable.
Les fonctionnalités de draft.blogger.com sont décrites ici sur le blog de Roberto.

Il est possible de tester l'éditeur directement depuis draft.blogger.com.
S'il convient, activer l'option "Faire de Blogger in Draft mon tableau de bord par défaut" dans le tableau de bord. Il sera ainsi possible de profiter de ce nouvel éditeur directement depuis les pages du blog.

Windows Live Writer

Pour les habitués de Microsoft, il semblerait qu'il existe un produit gratuit nommé "Windows Live Writer" (WLW).
Toujours en se fiant à l'article de Jean-Luc Tholozan, ce logiciel est compatible avec Blogger et offre une confort d'utilisation de loin bien plus agréable que l'éditeur en ligne de Blogger.
WLW supporte le copier/coller avec Word sans importer/générer de code html parasite (véritable plaie du support HTML de Word). WLW se présente là comme un excellent intermédiaire d'autant plus qu'il travaille en mode déconnecté. Finalement, et non des moindres, WLW gère parfaitement les caratères ">" , "<" et dispose d'un mode d'édition HTML.

Jean-Luc semblait assez satisfait de la combinaison Word + WLW + Blogger pour la production d'un blog.
A tester donc...

ScribeFire

Mentionné pour mémoire, ScribeFire est un plug-in FireFox permettant de facilité la publication de billet (y compris sur Blogger)

Quelques caratéristiques avancées du langage Python

Le langage Python dispose de quelques fonctions ou classes avancées qui peuvent se montrer vraiment utile dans des domaines pointus et pour le développement d'applications d'envergure.
Cet article reprend également quelques fonctions relatives aux éléments itérables.



__import__
__import__ est une primitive du langage permettant de charger un module (fichier .py) à la volée.
Cette primitive est principalement utilisé dans le cadre d'activation de modules plug-ins.

compile
La fonction compile permet de compiler du code source Pyhton à la volée.
Ce code source pouvant être contenu dans une chaine de caractère.
Par la suite, ce code compilé pourra être exécuté à l'aide de la primitive exec() ou eval().
Les cas d'utilisation de compile sont rare. Cependant, cette fonctionnalité convient très bien aux logiciels évolutifs (capable de se modifier par eux-mêmes).
Note:
Lors de l'utilisation de la fonction compile, il faut indique le mode de compilation.
Pour la compilation d'une expression à évaluer; le mode 'eval' convient très bien.
Bien qu'il soit indiqué que le mode 'single' convienne pour plusieurs instructions,  je n'ai eu un résultat probant  qu'en utilisant le mode 'exec' (voir l'exemple relatif à eval).

eval
Permet d'effectuer une évaluation (ou exécution) de code Python à la volée.
La fonction eval permet également d'utiliser le contexte actuel d'exécution (les variables définie et accessible au code appelant le seront également pour le code évalué) ou de définir le contexte d'exécution.

>>> myInt = 123
>>> sToEvaluate = 'myInt * 2'
>>> eval( sToEvaluate )
246
>>> # Modify the execution context
>>> eval( sToEvaluate, {'myInt' : 12} )
24
 
>>> sToEvaluate = 'x = 3\nprint( "%s * %s = %s" % (x, myInt, x*myInt) )'
>>> # Use 'exec' compilation mode because there are several lines!
>>> _compiled = compile( sToEvaluate, '/dev/null', 'exec' )
>>> eval( _compiled, {'myInt':12} )
3 * 12 = 36

execfile
Comme son nom le suggère, execfile permet d'exécuter le code contenu dans un fichier Python.
Cette exécution peut exploiter le contexte actuel ou redéfinir un contexte.

enumerate
Itération. Permet d'associer un indice/index numérique à chaque élément du contenu itérable.

>>> myList = [ 1, 13, 22, 4, 6, 17, 88, 65 ]
>>> for index, valeur in enumerate( myList ):
 print( 'valeur à l''index %s : %s' % (index, valeur) )

 
valeur à lindex 0 : 1
valeur à lindex 1 : 13
valeur à lindex 2 : 22
valeur à lindex 3 : 4
valeur à lindex 4 : 6
valeur à lindex 5 : 17
valeur à lindex 6 : 88
valeur à lindex 7 : 65
>>> myString = 'Hello !'
>>> for index, char in enumerate( myString ):
 print ( '%s - %s ' % (index, char) )

 
0 - H 
1 - e 
2 - l 
3 - l 
4 - o 
5 -   
6 - ! 

filter
Itération. La fonction filter permet de filtrer le contenu d'un tuple, list ou chaîne de caractères à l'aide d'une fonction. Seuls les éléments retournant True à la fonction de filtrage seront conservés.
None peut également être utilisé comme fonction de filtrage.
Dans ce cas, seul les éléments évalués comme True seront conservés (autrement dit, tout élément/objet ayant une référence). C'est une méthode bien pratique pour éliminer les éléments None d'une liste.

>>> myList = [ 1, 13, 22, 4, 6, 17, 88, 65 ]
>>> def myFilter( i ):
 return i>=10

>>> myFiltered = filter( myFilter, myList )
>>> for item in myFiltered:
 print item

 
13
22
17
88
65
>>> myString = "Voici une chaine de caractère. Je veux enlever les espaces"
>>> def isNotSpace( aChar ):
 return aChar != ' '

>>> myFilteredString = filter( isNotSpace, myString )
>>> print myFilteredString
Voiciunechainedecaractère.Jeveuxenleverlesespaces

reduce
Itération. Reduce permet d'appliquer une fonction de transformation de façon continu aux éléments d'une séquence.
Les 2 premiers éléments de la séquence sont utilisé avec la fonction.
Le résultat est alors utilisé avec le 3ième élément de la séquence pour rappeler la fonction.
Le nouveau résultat obtenu est alors utilisé avec le 4ième élément de la séquence pour rappeler la fonction.
Et ainsi de suite jusqu'à la fin de la séquence.

L'exemple suivant illustre parfaitement le fonctionnement de la fonction reduce.

>>> def somme( x, y):
...     print( '%d + %d = %d' % (x,y,x+y) )
...     return x+y
... 
>>> 
>>> reduce( somme, [1,2,3,4,5] )
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15

Reduce peut également prendre une valeur initiale en troisième argument.
Cela permet de reprendre/compléter une opération reduce avec des nouvelles données.

>>> # poursuivre le calcul avec le dernier résultat obtenu (15) comme
>>> # valeur initiale
>>> reduce( somme, [6,7,8,9,10], 15 )
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55
55
>>> # la somme des nombres de 1 à 10 fait 55

Cas d'utilisation:

• traitement de flux de donnée.
• Calcul récursif sur série de donnée (ex: calcul de moyenne).
  

map
Itération. Permet d'appliquer une fonction de transformation à chacun des éléments d'une structure itérable.
A noter que map peut être utilisé avec plusieurs listes. Dans ce cas, les éléments seront joints (un à un) et passés en paramètres de la fonction de transformation.
La fonction de transformation peut être None, dans ce cas, les éléments sont retournés (joint) tel quel et combinés en Tuple. Si l'une des liste est plus courte le tuple contiendra None pour l'élément manquant.

>>> myList = [1, 13, 22, 4, 6, 17, 88, 65]
>>> def mapTest( item ):
 return item*2

>>> newList = map( mapTest, myList )
>>> newList
[2, 26, 44, 8, 12, 34, 176, 130]

>>> myList = [1, 13, 22, 4, 6, 17, 88, 65]
>>> myList2 = ['A', 'b', 'c', 'd']
>>> def mapTest2( item1, item2 ):
        # str the items to avoids the error:
        # TypeError: cannot concatenate 'str' and 'NoneType' objects
 return str(item1)+'-'+str(item2)
>>> newList = map( mapTest2, myList, myList2 )
>>> newList
['1-A', '13-b', '22-c', '4-d', '6-None', '17-None', '88-None', '65-None']

>>> # mapping with None as function
>>> #   In this case this create TUPLES
>>> newList = map( None, myList, myList2 )
>>> newList
[(1, 'A'), (13, 'b'), (22, 'c'), (4, 'd'), (6, None), (17, None), (88, None), (65, None)]

>>> # mapping strings with None as function
>>> str1 = 'elements'
>>> str2 = 'langage'
>>> newList = map( None, str1, str2 )
>>> newList
[('e', 'l'), ('l', 'a'), ('e', 'n'), ('m', 'g'), ('e', 'a'), ('n', 'g'), ('t', 'e'), ('s', None)]
>>> # Autre usage des tuples
>>> for item1, item2 in map( None, str1, str2 ):
 print str( item1 )
 print ' +-> '+str( item2 ) 
e
 +-> l
l
 +-> a
e
 +-> n
m
 +-> g
e
 +-> a
n
 +-> g
t
 +-> e
s
 +-> None

all
Itération. Permet de tester l'homogénéité d'une séquence.
La fonction all retourne true si tous tous les éléments d'une séquence peuvent être évalués comme vrai.
Les éléments évalués peuvent être des références d'objets (assignés=True ou None=False) ou des expressions booléennes.

>>> mySeq1 = [ 1, 2, 'a', None ]
>>> mySeq2 = [ 1, 2, 'a', 3 ]
>>> mySeq3 = [ 1, 10, 20, 60 ]

>>> # Teste si tous les éléments sont assignés
>>> all( mySeq1 )
False
>>> all( mySeq2 )
True

>>> # Test d'homogénéité
>>> all( isinstance( el, int ) for el in mySeq1 )
False
>>> all( isinstance( el, int ) for el in mySeq2 )
False
>>> all( isinstance( el, int ) for el in mySeq3 )
True

>>> # Utilisation des [ ] pour construire un élément itérable
>>> print [ isinstance( el, int ) for el in mySeq3 ]
[True, True, True, True]
>>> # Test avec la nouvelle notation
>>> print all( [ isinstance( el, int ) for el in mySeq3 ] )
True

any
Itération. Permet de tester facilement le contenu d'une séquence.
La fonction any retourne true si au moins un des éléments de la séquence séquence peut être évalué comme vrai.
Les éléments évalués peuvent être des références d'objets (assignés ou None) ou des expressions booléennes.

>>> mySeq1 = [ 1, 2, 'a', None ]
>>> mySeq2 = [ 1, 2, 'a', 3 ]
>>> mySeq3 = [ 1, 10, 20, 60 ]

>>> print any( el > 10 for el in mySeq1 )
True
>>> print any( el > 10 for el in mySeq2 )
True
>>> print any( el > 10 for el in mySeq3 )
True
>>> print any( [ el > 10 for el in mySeq1 ] )
True
>>> print any( [ el > 10 for el in mySeq2 ] )
True
>>> print any( [ el > 10 for el in mySeq3 ] )
True
>>> print any( [ isinstance( el, str ) for el in mySeq1 ] )
True
>>> print any( [ isinstance( el, str ) for el in mySeq2 ] )
True
>>> print any( [ isinstance( el, str ) for el in mySeq3 ] )
False

Petit exemple complémentaire sur le blog amix.dk

Sql Serveur - Converting une string Hexa en caratère

En Sql Serveur, il n'est pas si simple de convertir une string contenant une valeur hexadécimale en en caractère.
J'ai trouvé la réponse à cette épineuse question sur l'article "T-SQL Convert Hex String to Varbinary" de Peter DeBetta. La fonction HexStrToVarBin de Peter permet ce petit tour de passe-passe.

Exemple:

-- === CONVERT SIMPLE BYTE ================
DECLARE @strData Varchar(2)
-- Some programming extracting a hex digit
SET @strData = '4A'
print 'Conversion on simple char' 
print Char( dbo.HexStrToVarBin( '0x'+@StrData ) ) 

-- === CONVERT SEQUENCE OF BYTES ==========
DECLARE @strData2 Varchar(20)
-- Some programming extracting a hex digit
SET @strData2 = '4A4B4C4D'
print 'Conversion to sequence of char' 
print Cast( dbo.HexStrToVarBin( '0x'+@StrData2 ) as Varchar(10) )

Résultat:

Conversion on simple char
J
Conversion to sequence of char
JKLM

Python - Cas pratique 2

Deuxième cas pratique d'utilisation de script Python utilisant XML (libxml), XSL (d'un browser), les itérables et ODBC (pyODBC).

En résumé, ce script Python effectue les opérations suivantes:

1. Connecter une DB MS SqlServeur pour lister le nom de certaines tables et leurs colonnes (en utilisant sysobjects et syscolumns).
2. Etablir une structure Python en mémoire avec ces informations.
3. Enrichir la structure (avec des informations complémentaires comme les datatypes, type delphi, etc)
4. Transformation de la structure en document XML + enregistrement dans un fichier.
5. Utilisation d'une XSL pour générer des classes Delphi sur base du contenu XML.
   Pour ce faire, ouvrir le fichier XML avec un Browser. Le code Delphi résultant est visible dans Browser. Utiliser de préférence FireFox car IE6 (par exemple) à la mauvaise manie d'ignorer les CR pour un output de type "text".

Code source, fichier xml et xsl disponibles ici.


Information relative au code source:
Le fichier XML imtermédiaire est fourni avec le code source. Cependant, son contenu a été fortement et volontairement altéré (name scrambling). D'autre part, il ne reste plus d'information sensible sur la ConnectionString dans le code Python.
La transformation XSL du type TzzzDateTime ne sera pas correct car, bien évidemment, il ne s'agit pas du type réel. Bien que le principe de fonctionnement soit correct, le code généré avec cet exemple ne compilera pas.