Ignorer des fichiers sur l’ensemble d’un projet SVN

Si votre IDE génère des fichiers de préférence utilisateur qui ne devraient pas être présent sur votre repository (prenons l’exemple d’Xcode et ses .pbxuser) il convient d’utiliser la commande SVN ignore.

Pour l’ignorer sur toute l’arborescence du projet, il faut se placer a la racine du dossier sous contrôle de version, et déclarer la property de cette manière :

svn propset svn:ignore ‘*.pbxuser’ . –recursive

Ainsi les fichiers portant l’extension pbxuser ne seront plus sous contrôle de version et n’apparaitrons plus lors des svn stat.

29 juin 2011 at 10 h 39 min Poster un commentaire

A few things iOS developers ought to know about the ARM architecture (via Wandering Coder)

very good low level introduction to the iphone development.

When I wrote my Introduction to NEON on iPhone, I considered some knowledge about the iOS devices’ processors as assumed to be known by the reader. However, from some discussions online I have realized some of this knowledge was not universal; my bad. Furthermore these are things I think are useful for iPhone programming in general (not just if you’re interested in NEON), even if you program in high-level Objective-C. You could live without them, … Read More

via Wandering Coder

11 janvier 2011 at 15 h 07 min Poster un commentaire

Utiliser Git et Xcode 3

Ceux qui ont téléchargé la bêta de Xcode 4 peuvent d’ores et déjà profiter de l’intégration de Git à leur IDE favori :).
Mais ceux qui possèdent un Mac Mini par exemple ont aussi pu apprécier la lourdeur et l’instabilité de la dernière bêta de cette dernière version, préférant continuer à travailler sous la version 3 de Xcode.

A chaque ouverture de votre projet Xcode, les données du dossier .pbxproj vont être modifiées, polluant votre index Git. Nous allons donc utiliser la commande de git permettant d’ignorer certains fichiers, afin que seuls vos codes sources et vos fichiers utilisés par le projets soient sous contrôle de version.

Premièrement, nous allons crééer un fichier .gitignore à la racine du dossier du projet controlé par git.

Dans ce fichier nous renseignons ces lignes :

# fichiers xcode a ignorer
build/*
*.pbxuser
*.mode1v3

# fichiers osx a ignorer
.DS_Store
profile

Référence : http://www.kernel.org/pub/software/scm/git/docs/gitignore.html

Mais si comme moi vous avez déja commité ces fichiers sur votre repository git, alors il vous faudra les enlever (en anglais "untrack") du controle de version avec la commande :

git rm -f nom_de_projet.xcodeproj/nom_utilisateur.*
git rm -f build/*
et enfin
git commit -m "remove useless files"

Rassurez-vous car si ces fichiers seront enlevés du disque dur, le build sera recréé à la prochaine compilation du projet, et les fichiers de préférences utilisateur du .pbxproj seront regénérés automatiquement par xcode.

24 août 2010 at 22 h 30 min Poster un commentaire

backup your mysql database everynight with a shell script.

To save your password protect mysql database into a file, use the mysqldump utility.

#!/bin/bash
DATABASE_NAME=name
MYSQL_USER=utilisateur
MYSQL_PASSWORD=password
mysqldump --user=$MYSQL_USER --password=$MYSQL_PASSWORD $DATABASE_NAME -q --single-transaction --complete-insert| bzip2 > $(date +%F-%T)_$DATABASE_NAME.sql.backup

Référence complète de mysqldump :
http://dev.mysql.com/doc/refman/5.0/fr/mysqldump.html

23 mai 2010 at 15 h 22 min Poster un commentaire

Enums en Java 1.5 et le problème de Java 1.4

En travaillant sur les mini jeux de horsepark.fr, développés sur la base du framework pulpcore, je me suis aperçu qu’il n’était pas possible d’utiliser les "enums", fonctionnalité apportée par java 1.5.
Cette limitation provient du fait que les applets Java doivent être compatibles avec Java 1.4, et que pulpcore supporte la syntaxe de Java 1.5 par le biais de retroguard… qui ne supporte pas actuellement cette syntaxe.

Dommage, car l’élégance apportée par ce nouveau type de classe est franchement appréciable.
Voici une petite comparaison des morceaux de code écrits avec les deux versions.

L’exemple est le suivant :
Imaginez une machine a état gérant les paramètres d’animation de votre jeu en fonction des entrées clavier correspondantes. A chaque état est associé un certain nombre de valeurs pour les paramètres, comme par exemple : sens du déplacement, vitesse d’animation du sprite, nom de l’état (course, marche, arret)…

Avec le type enum apporté par java 5, on déclare un type enum, contenant chacun des paramètres, déclarés dans le constructeur de l’enum, et avec un nombre fini d’instances:

public static int SpriteState {
ACTOR_BACK (1000, -1, "En arrière");
ACTOR_STOPPED (0, 0, "Au repos"),
ACTOR_WALK (1000, 1, "En route") ,
ACTOR_RUN (5000, 1, "Dépêchons nous!"),

private final int animSpeed;
private final int animDirection;
private final String animDescription;

SpriteState(int animSpeed, int animDirection, String animDescription) {
this.animSpeed = animSpeed;
this. animDirection = animDirection;
this. animDescription = animDescription;
}

public int speed() {
return this.animSpeed;
}
public int direction() {
return animDirection;
}
public int description() {
return animDescription;
}
}

Notre enumération d’état et nos paramètre sont regroupés et externalisés de la logique du contrôleur. Ainsi dans la boucle prinicipale, il suffit d’utiliser ce morceau de code pour changer d’état en réaction des entrées de l’utilisateur :

(code du contrôleur)

public void update(int elapsedTime) {
super.update(elapsedTime);
actor.update(elapsedTime);
if (Input.getState(Input.KEY_LEFT) == Input.DOWN) {
this.setGameState(SpriteState.values()[(current_state.ordinal()-1)]);

} else if (Input.getState(Input.KEY_RIGHT) == Input.DOWN) {
this.setGameState(SpriteState.values()[(current_state.ordinal()+1)]);
}
}

public void setGameState (SpriteState s) {
actor.changeDuration(s.duration());
actor.setDirection(s.direction());
hud.setDescription(s.Description());
System.out.println("Nouvel etat : "+ current_state.ordinal());
}

En java 1.4, les enums ne sont qu’en réalité un tableaux de valeurs entières (int).


public class SpriteState {
public static final int ACTOR_BACK = 0;
public static final int ACTOR_STOP = 1;
public static final int ACTOR_WALK = 2;
public static final int ACTOR_RUN = 3;

public static final int[] ANIM_SPEED_VALUES = {1000,0,1000,5000};
public static final String[] ANIM_DESCRIPTION_VALUES = {"En arrière","Au repos","En route","Dépêchons nous"};
public static final int[] ANIM_DIRECTION_VALUES = {-1,0,1,1};
}

Les paramètres de chaque enums ne sont pas liés a nos valeurs d’enum.
Dans l’implémentation du contrôleur, cela se traduit par un test long et peu lisible, avec une logique qui n’est pas forcément isolée de la valeur des paramètres (du coup difficile et pénible à modifier si vos états sont repris dans plusieurs classes);

public void setGameState (int s) {
switch (s) {
case SpriteState. ACTOR_BACK:
CoreSystem.print("Nouvel etat : Arret");
actorSprite.changeDuration(SpriteState.DRESSAGE_ANIM_SPEED[SpriteState.DRESSAGE_ARRET]);
case SpriteState. ACTOR_STOP:
System.out.println("Nouvel etat : Pas");
actorSprite.changeDuration(SpriteState.DRESSAGE_ANIM_SPEED[SpriteState.DRESSAGE_PAS]);
case SpriteState. ACTOR_WALK:
System.out.println("Nouvel etat : Trot");
actorSprite.changeDuration(SpriteState.DRESSAGE_ANIM_SPEED[SpriteState.DRESSAGE_TROT]);
case SpriteState. ACTOR_RUN:
System.out.println("Nouvel etat : Galop");
actorSprite.changeDuration(SpriteState.DRESSAGE_ANIM_SPEED[SpriteState.DRESSAGE_GALOP]);
}
}

NDA : vous aurez compris le principe il manque a ce sample code la mise a jour du hud et de la direction de l’animation

Toutefois, si vous voulez réimplémenter le comportement des enums en java, cela est possible, avec un peu de travail en plus. Le pattern s’appelle "Typesafe Enum". A vous de trouver le bon compromis …
implémenter les enums sur java 1.4 : http://www.javacamp.org/designPattern/enum.html
référence : http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html

1 mai 2010 at 15 h 04 min Poster un commentaire

Clé composites en SQL

L’intérêt d’une clé composite / composée est de pouvoir utiliser plusieurs champs différents en tant que clé primaire d’une table. En effet, si l’association de deux colonnes est unique, pourquoi recréér artificellement un id qui ne servirait que de clé primaire ?

Illustration :


CREATE TABLE example1(
field1 text not null,
field2 text not null,
PRIMARY KEY (field1, field2)
);

17 février 2010 at 16 h 12 min Poster un commentaire

Requete SELECT subtile… comment afficher de manière unique un résultat d’une requête SQL ?

Si vous avez une requête SQL donnant un résultat avec des doublons et que vous souhaitez éliminer les doublons pour avoir ces résultats de manière unique, pensez à utiliser le mot clé DISTINCT.

Exemple imaginons que vous souhaitiez extraire les emails de vos clients n’ayant pas acheté depuis une certaine date. Vous disposez d’une table "orders" et "clients"… Notre requête ressemblera à cela

SELECT email, name FROM clients,order WHERE order.date < 20090601 (ou un timestamp quelconque…);

Si dans votre réponse vous obtenez plusieurs fois le meme mail, hop, DISTINCT vous assurera de l’unicité de vos résultats ! Chacun des champs de la table retournée sera unique.

La requête devient donc :

SELECT DISTINCT email, name FROM clients,order WHERE order.date < 20090601 (ou un timestamp quelconque…);

Pratique non ?

22 novembre 2009 at 16 h 22 min Poster un commentaire

Articles Précédents


Articles récents


Suivre

Recevez les nouvelles publications par mail.

Rejoignez 685 autres abonnés