# Problème de type en C



## greensource (12 Mars 2008)

J'ai fini un TP de C sur les listes, à la fac nickel tout fonctionne très bien, je décide de tranferer le tout sous Xcode3, et la patatra une méchante erreur sus nommé:_"incompatible types in assignement"_
Elle ce trouve dans cette fonction:
Elle cree un nouvel element pour la liste

```
list_elem_t* create_element(char *a_name) {
  if (strlen(a_name)>=20){
    return NULL;
      }
  else {
    list_elem_t* p1=(list_elem_t*)malloc (sizeof(list_elem_t));
    if (p1 != NULL){
      p1->next=NULL;
      p1->prev=NULL;
      [COLOR="Red"]p1->name=(char*) malloc(sizeof (char) *strlen(a_name));[/COLOR]
      strcpy(p1->name,a_name);
      return p1;
    }
    else {return NULL;}
  }
}
```
Bon faut avouer en plus que je comprend pas très bien comment fonctionne cette ligne ^^. Je comprend bien qu'elle alloue de l'espace mémoire mais pourquoi utilisé "strlen()"? Et pourquoi le cast "(char)" juste après sizeof?

Je joint le projet Xcode au cas ou. Merci

[edit]Je viens de tester en enlevant carrément la ligne et ça marche ??? Et aussi j'ai tout compilé à la main (ils nous on filé un makefile) et ça fonctionne nickel aussi, pas d'erreur de type!


----------



## FataMorgana (12 Mars 2008)

greensource a dit:


> J'ai fini un TP de C sur les listes, à la fac nickel tout fonctionne très bien, je décide de tranferer le tout sous Xcode3, et la patatra une méchante erreur sus nommé:_"incompatible types in assignement"_
> Elle ce trouve dans cette fonction:
> Elle cree un nouvel element pour la liste
> 
> ...



Coucou pour l'erreur c'est peut-être simplement parce que tu utilises gcc-4 qui est beaucoup plus méchant que gcc 3... avec gcc_select tu peux choisir sur mac...
A+


----------



## greensource (12 Mars 2008)

J'essaierais mais je crois pas que cela vienne de la car j'arrive à compiler sans erreur via le makefile. Mais je vais voir.


----------



## FataMorgana (12 Mars 2008)

greensource a dit:


> J'essaierais mais je crois pas que cela vienne de la car j'arrive à compiler sans erreur via le makefile. Mais je vais voir.



Dans le makefile y a un export de CC? 
A+


----------



## Leoparde (12 Mars 2008)

essai de mettre calloc au lieu de malloc

[edit] lit plutôt ce qu'a écrit grumff
 Sinon, si sa t'aide :


> malloc


Alloue de la mémoire


> sizeof


de la taille


> (char) *strlen(a_name)


d'une chaine de caractére dont le nombre de caractére est déduit du pointeur (j'ai trop été tromatisé par les pointeur moi) a_name


----------



## grumff (12 Mars 2008)

Alors la ligne en question elle alloue de la mémoire en faisant un strlen(a_name)*sizeof(char) parce que pour pouvoir stocker la chaine il faut pouvoir stocker tous les caractères, donc le nombre de caractères multiplié par la taille d'un caractère en mémoire.
J'aurais déjà tendance à penser qu'il faut allouer un caractère de plus pour le caractère de fin de chaîne (\0), tu peux toujours corriger ça. Après sizeof ce n'est pas un cast, sizeof c'est une fonction qui indique la taille d'un type de données, donc il faut lui indiquer qu'on veut savoir quelle taille occupe un char en mémoire (en général c'est 1, ça varie pas beaucoup contrairement aux int, mais mieux vaut le laisser comme ça pour la compatibilité future...).
Le champ name de list_elem_t c'est bien un char * ?


----------



## Didier Guillion (13 Mars 2008)

Ouch ! Ouch !
Tu fait une grosse confusion de type.
Le membre "name" de ta structure s_list est un tableau de char PAS un pointeur sur des chars

Donc tu declare

typedef struct s_list {
	char *  name;
	struct s_list* next;
	struct s_list* prev;
} list_elem_t;

et ca va le faire.

N'oublie de liberer la memoire via free

Cordialement


----------



## tatouille (13 Mars 2008)

```
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

static char *_array_err_str = NULL;

enum {
    ARRAY_ERRNO,
    ARRAY_NEW,
    ARRAY_ONITEM
};

enum {
    ARRAY_CTYPE_STRING,
    ARRAY_CTYPE_STRING_ALLOCED,
    ARRAY_CTYPE_INT32,
    ARRAY_CTYPE_UINT32,
    ARRAY_CTYPE_FLOAT,
    ARRAY_CTYPE_DOUBLE
};

#define ARRAY_CAST_STRING_T (char *)
#define ARRAY_CAST_INT32_T *(int *)
#define ARRAY_CAST_UINT32_T *(unsigned int *)
#define ARRAY_CAST_FLOAT_T *(float *)
#define ARRAY_CAST_DOUBLE_T *(double *)

typedef struct {
    unsigned index;
    const void *value;
    unsigned type;
} array_item_t;

typedef struct {
    int status;
    int count;
    array_item_t *items;
} array_t;

array_t *array_new(void) {
    array_t *arr;
    
    if ( NULL == (arr = malloc(sizeof(array_t) + 1)) ) {
        errno = ENOMEM;
        return NULL;
    }
    
    if ( NULL == (arr->items = malloc(sizeof(array_item_t) + 1))) {
        errno = ENOMEM;
        return NULL;
    }
    
    arr->status = ARRAY_NEW;
    arr->count = 0;
    
    return arr;
}

int array_geterrno(void) {
    if (errno)
        return errno;
        
    return -1;
}

bool array_iserror(bool print) {
    if (errno && NULL != _array_err_str) {
        switch(print) {
            case false: break;
            case true:
                perror((const char *)_array_err_str); break;
        }
        
        _array_err_str = NULL;
        return true;
    }
    
    return false;
}

bool array_addvalue(
    array_t *arr, const void *value, int type)
{
    array_item_t *items;
    unsigned idx = 0;
    
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_addvalue";
        return false;
    }
    
    if (!arr->status)
        return false;
    
    if ( NULL == (items = realloc(arr->items, (sizeof *items)*(arr->count + 1))) ) {
        arr->status = ARRAY_ERRNO;
        errno = ENOMEM;
        return false;
    }
    
    idx = arr->count++;
    arr->items = items;
    arr->items[idx].type = type;
    arr->items[idx].value = value;    
    arr->items[idx].index = idx;
    arr->status = ARRAY_ONITEM;
    
    return true;
}

bool array_addstring(
    array_t *arr, const char *string, bool allocate)
{    
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_addstring";
        return false;
    }
    
    return array_addvalue(arr, 
        (allocate && NULL != string) ? strdup(string) : string, 
        (allocate && NULL != string) ? ARRAY_CTYPE_STRING_ALLOCED : ARRAY_CTYPE_STRING);
}

bool array_addnumber(
    array_t *arr, void *number, int type)
{
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_addnumber";
        return false;
    }
    
    return array_addvalue(arr, number, type);
}

bool array_show(
    array_t *arr)
{
    unsigned i = 0;
    
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_show";
        return false;
    }
    
    if (!arr->status) {
        errno = EINVAL;
        _array_err_str = "array_show";
        return false;
    }
    
    do {
        switch(arr->items[i].type) {
            case ARRAY_CTYPE_STRING:
            case ARRAY_CTYPE_STRING_ALLOCED:
                if( NULL != arr->items[i].value)
                    printf("array[%u] = \"%s\" \n",i, 
                        ARRAY_CAST_STRING_T arr->items[i].value);
                else
                    printf("array[%u] = NULL \n",i);
            break;
            case ARRAY_CTYPE_INT32:
                printf("array[%u] = %i \n",i, 
                    ARRAY_CAST_INT32_T arr->items[i].value);
            break;
            case ARRAY_CTYPE_UINT32:
                printf("array[%u] = %u \n",i, 
                    ARRAY_CAST_UINT32_T arr->items[i].value);
            break;
            case ARRAY_CTYPE_FLOAT:
                printf("array[%u] = %f \n",i, 
                    ARRAY_CAST_FLOAT_T arr->items[i].value);
            break;
            case ARRAY_CTYPE_DOUBLE:
                printf("array[%u] = %f \n",i, 
                    ARRAY_CAST_DOUBLE_T arr->items[i].value);
            break;
        }
    } while(++i < arr->count);    
        
    if (i)
        return true;
        
    return false;    
}

const void *array_getvalue(
    array_t *arr, unsigned idx)
{
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_getvalue";
        return false;
    }
    
    if ( 2 != arr->status || arr->count < 0)
        return NULL;
    
    if ( idx < arr->count && arr >= 0) {
        return arr->items[idx].value;
    }    
        
    return NULL;    
}

bool array_delvalue(
    array_t *arr, unsigned idx)
{
    array_t *cpy;
    unsigned i = 0;
    
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_delvalue";
        return false;
    }
    
    if ( 2 != arr->status || arr->count < 0)
        return false;
        
    if ( idx < arr->count && idx >= 0) {
        cpy = array_new();
        
        do {
            if ( idx != arr->items[i].index)
                array_addvalue(cpy, 
                    arr->items[i].value, arr->items[i].type);
        } while(++i < arr->count);
        
        free(arr->items);
        free(arr);
        
        *arr = *cpy;
        
        return true;
    }    
        
    return false;
}

int array_getcount(
    array_t *arr) {
    
    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_getcount";
        return 0;
    }
    
    if (!arr->count) {
        errno = EINVAL;
        _array_err_str = "array_getcount";
        return 0;
    }
    
    return arr->count;
}

bool array_free(
    array_t *arr) 
{
    unsigned i = 0;

    if (NULL == arr) {
        errno = EINVAL;
        _array_err_str = "array_free";
        return false;
    }
    
    if (!arr->items) {
        errno = EINVAL;
        _array_err_str = "array_free";
        free(arr);
        arr = NULL;
        return false;
    }
    
    if (arr->count) {
        do {
            if ( arr->items[i].type == ARRAY_CTYPE_STRING_ALLOCED)
                free((void *)arr->items[i].value);
        } while(++i < arr->count);
    }
    
    free(arr->items);
    free(arr);
    
    return true;
}

int main(void)
{
    array_t *arr;

    int int_val;
    float float_val, float_val_ret;
    double double_val, double_val_ret;
    
    char *string_a = "string_a string_a string_a";
    char *string_b = "string_b string_b string_b";
    
    arr = array_new();

    int_val = 10;
    float_val = 10.567889;
    double_val = 1444444448.144449;
        
    array_addnumber(arr,
        &int_val, ARRAY_CTYPE_INT32);
        
    array_addnumber(arr,
        &float_val, ARRAY_CTYPE_FLOAT);
        
    array_addnumber(arr,
        &double_val, ARRAY_CTYPE_DOUBLE);
    
    array_addstring(arr, string_a, false);
    array_addstring(arr, string_b, false);
    array_addstring(arr, NULL, false);
    
    array_show(arr);
    
    array_delvalue(arr, 3);
    
    array_show(arr);
    
    puts("---");
    
    float_val_ret = ARRAY_CAST_FLOAT_T array_getvalue(arr, 1);
    
    printf("%f \n", float_val);
    
    puts("---");
    
    double_val_ret = ARRAY_CAST_DOUBLE_T array_getvalue(arr, 1);
    
    printf("%f \n", double_val);
    
    puts("---");
    
    return 0;
}
```


----------



## greensource (13 Mars 2008)

Didier Guillion a dit:


> Ouch ! Ouch !
> Tu fait une grosse confusion de type.
> Le membre "name" de ta structure s_list est un tableau de char PAS un pointeur sur des chars


Bas je comprends pas en effet ^^ 
En cours on nous rabâche depuis le début que pointeurs et tableau c'est grosso modo pareil à la différence que le tableau réserve un espace mémoire. Moi c'est bien un tableau qui a une certaines taille que je veux (char name[MAX_NAME]).
Ta solution (qui à le mérite de marcher au demeurant  ) elle me réserve pas d'espace? Je pourrais avoir une chaîne de plus de MAX_NAME char non?
Et puis c'est quand même bizarre que ça marche avec le makefile et pas dans Xcode?

Sinon j'ai pas saisi tatouille ce que tu as mis en code? C'est l'implémentation des chaînes en C?

Bon en tout cas merci tous c'est bien sympas


----------



## grumff (13 Mars 2008)

Un tableau c'est un pointeur, donc c'est grosso modo la même chose. Sauf que quand tu le déclares avec une taille fixe, il alloue la mémoire à l'avance, donc ça ne lui plaît pas que tu veuilles la réallouer après. Tu lui modifie son occupation mémoire alors que le type reste le même, avoir une chaîne de 50 caractères dans une structure de donnée qui s'appelle "tableau de 20 caractères", ça pose un problème.
Bref, oui un tableau et un pointeur c'est la même chose, tu les utilises de la même façon. Sauf pour ce qui est des allocations mémoires...

Bref, soit tu laisses ton tableau et tu vires l'allocation mémoire qui devient inutile (mais tu ne pourras plus stocker des chaînes de caractères plus grandes que la taille du tableau), soit tu mets un pointeur dans ta structure de données, et tu laisses l'allocation dynamique.


----------



## tatouille (14 Mars 2008)

@greensource:
non c et une class array ou list et une bonne illustration pour les pointeurs, ca depend des flags
un a retenir pour tout projet -Werror, 
le __restrict est theoriquemnt possible

@grumff

```
#include <stdio.h>
#include <string.h>

int main(void) {
    char arr[20] = "hello wolrd!";
    char *ch_arr = arr;
    unsigned char ptr = *ch_arr + 10;
    
    printf("%c \n", ptr);
    printf("%s \n", ch_arr);
    
    ptr = *ch_arr + 90;
    
    printf("%c \n", ptr);

    ptr = ptr + 2;
    
    printf("%c \n", ptr);
    
    return 0;
}
```
t' toujours aussi affreuses ces raillures bleues 

@Didier: 
ca illustre bien ce que tu disais "de ce qui pointe et de ce qui est pointé", pour moi la il ya un probleme d'enseignement, car c est quand meme pas complique bordel , 

en tous les cas je trouve ca marrant , enfin je constate ce faite provenant de l ensignement actuel:
en python ou le language ne pointe que vers des addrs d objets 
ca ne leurs posent pas de probleme, et quand tu expliques d ou ca vient et comment ca marche le capotage

c est allucinant d avoir quelqu'un qui part sur un tp list et ptr sur objet sans avoir compris le plus simple, on dirait qu il n'y a personne pour verouiller et verifier les acquis?


----------



## Eul Mulot (14 Mars 2008)

tatouille a dit:


> c est allucinant d avoir quelqu'un qui part sur un tp list et ptr sur objet sans avoir compris le plus simple, on dirait qu il n'y a personne pour verouiller et verifier les acquis?



En deux ans d'I.U.T., j'ai eu le droit à un seul module de C (environ 20/25 H). Ce qu'on a vu en C, c'était vraiment les bases (pointeurs, mallocs, makefile, listes chainées). Après le C qu'on faisait restait très "Javaesque". D'ailleurs en 2 ans de cours, j'ai mangé du Java du premier jour au dernier, sympa mais bien saoulant tout de même, à croire que le C est mort.

De plus on a commencé la 1 ère année par le Java, puis le C est venu en S2, je vous raconte même pas les gens qui avaient l'air d'avoir vu un truc infame quand on a abordé les pointeurs ...

Je pense comme Tatouille que c'est clairement un problème de pédagogie. Après, il faut que les écoles s'adaptent leurs programmes à ce que les boites demandent, mais c'est frustrant de se manger deux ans de Java et un module riquiqui de C.


----------



## Didier Guillion (14 Mars 2008)

Le jour où je voudrait vraiment apprendre a faire du pain, je ne passerait pas un an à lire des bouquins ou a suivre des cours théoriques, j'irait bosser chez un boulanger.

Dans les écoles d'infos ou les facs, on donne les bases on n'apprends pas vraiment à travailler. Après, chacun a un ordinateur chez lui et c'est une question de choix, Doom IV en réseau avec les potes ou le C, Java, Python, Perl sur un vrai projet. C'est vrai que le plan B parait moins fun.

Quand je vois des CV arriver provenant de petits jeunes de 22 ans qui disent maitriser cinq ou six langages, je me dit que cela va mal se passer pour eux en entreprise.

Le CV idéal tient en deux lignes : "C'est moi qui ai fait cela" suivit de l'URL de téléchargement.

Ce n'est que mon avis.

Pour en revenir au sujet, si GreenSource veut qu'on relise son code final, qu'il n'hésite pas.

Cordialement


----------



## Vivid (14 Mars 2008)

Didier Guillion a dit:


> Le CV idéal tient en deux lignes : "C'est moi qui ai fait cela" suivit de l'URL de téléchargement.
> 
> Ce n'est que mon avis.



c'est exactement ce que j'ai fait, pour être crédible, j'ai même pas le bac alors.. cela a marcher! un chasseur de tête m'a recruter ! et vaut mieux pas dire de quoi tu vie, parceque avec les gros c... (biiiiiiiip) français, on te m'éprise, on t'ignore on te prend pour le pathétique pauvre type, faut en plus sauter les barrieres, tout les 'bouseux' qui filtre (secretaires...) depuis internet de ce côté là.. ouf! 

Un bon enseignant est un ancien professionel, quand tu maîtrise,  tu est forcément pédagogue surtout dans ce domaine. Mais les concours...


----------



## grumff (14 Mars 2008)

Didier Guillion a dit:


> Le jour où je voudrait vraiment apprendre a faire du pain, je ne passerait pas un an à lire des bouquins ou a suivre des cours théoriques, j'irait bosser chez un boulanger.
> 
> Dans les écoles d'infos ou les facs, on donne les bases on n'apprends pas vraiment à travailler. Après, chacun a un ordinateur chez lui et c'est une question de choix, Doom IV en réseau avec les potes ou le C, Java, Python, Perl sur un vrai projet. C'est vrai que le plan B parait moins fun.


Je trouve que t'exagère un petit peu, je parle pour la fac parce que je suis passé par là, et même par 3 universités différentes, on a quand même un certains nombres de projets, qui sont des vrais projets sur des cas concrets, peut-être même beaucoup plus complexes que ce qu'on fait au final en entreprise... (j'ai eu a développer un compilateur pascal, un logiciel de p2p, un portail de vente en J2EE, et j'en passe, je trouve ça plutôt concret). On a au aussi eu pas mal d'heures de TP encadrés, bref, c'est loin d'être que du théorique.  J'irais pas non plus venter l'enseingement universitaire, je pense qu'on pourrait faire aussi bien avec 2x moins de cours, mais l'objectif n'est pas forcément que de fournir des connaissances, c'est aussi de sélectionner... Y'a les connaissances et y'a la capacité à en tirer partie, qui ne s'apprend pas.
Et puis pour ma part, j'ai passé beaucoup plus d'heures de mon temps libre sur les jeux en réseau que sur du dev... Je suis pas plus mauvais que les autres pour autant, j'irais même prétendre le contraire. Faut arrêter de croire qu'un bon développeur est un geek qui n'a d'autres loisirs que son shell, tous ceux que j'ai vu dans cette catégorie étaient loin d'être les plus doués.



> Quand je vois des CV arriver provenant de petits jeunes de 22 ans qui disent maitriser cinq ou six langages, je me dit que cela va mal se passer pour eux en entreprise.
> 
> Le CV idéal tient en deux lignes : "C'est moi qui ai fait cela" suivit de l'URL de téléchargement.
> 
> ...


Juger sur des programmes développés, c'est assez hasardeux, d'abord parce que tu ne peux jamais être sur de qui les a fait, ensuite parce que tu n'en connais pas le contexte : temps passé, nombre de personnes à avoir travaillé dessus, individus passés les vérifier, sans parler du temps nécessaire pour aller y jeter un oeil. Bref, je suis pas sûr que cette méthode soit meilleur, mais je laisse le recrutement aux personnes qu'en ont la charge. Je crois que c'est un métier à part entirèe. Même si j'ai bien une théorie très personnelle qui dit qu'on en saurait peut-être déjà long en se basant sur la moyenne de maths de 3e.


----------



## Didier Guillion (14 Mars 2008)

Merci Grumff,

Cela me rassure qu'il y ait de bonne formations en Fac, et je suis sur que cela a évolué depuis le temps ou je donnait des cours au profs d'informatiques a l'Université Paul Sabatier de Toulouse.

Je ne dénigre en aucun cas les formations théoriques, simplement, je voudrais qu'elles soient completées par quelque chose de concret, de solide.

Alors vas y, envoie nous un lien sur ce que tu as fait...


Cordialement


----------



## grumff (14 Mars 2008)

Faudrait que je fasse le tri dans le dossier "bordel fac" pour ça...  C'est un peu un bordel sans nom avec 15 versions de chaque projet dans des états non aboutis et avec des noms pas très explicites. C'était conçu pour que je m'y retrouve sur le moment, pas pour durer...  Et comme ils ont omis de me présenter cvs... (du moins, ils m'ont présenté ça à l'aide de 3 lignes de commandes et assez tardivement, vu comme ça j'y ai vu plus de contraintes que d'atouts). Donc j'ai rien à te présenter en l'état. Après y'a ce que j'ai fais à titre personnel mais c'est du web, le plus aboutis c'est le site du clan m4k fait avec Slug.

Et puis me fait pas dire ce que je n'ai pas dit, j'ai pas dis qu'il y avait que des profs compétents. .. Et j'ai pas dis qu'ils étaient majoritaires non plus.  Je dis juste qu'au final le bilan de ma formation n'est pas si mauvais que ça. J'ai en particulier eu un paquet d'enseignants totalement incompétents à Dijon (où j'ai fais mon DEUG), et j'ai aussi été très sceptique sur mon année de M2 à Grenoble dont à mon avis la reconnaissance auprès des entreprise est beaucoup plus due à la sélection à l'entrée qu'à ce qu'on y apprend. Mais sinon sur Lyon j'ai vu quelques bonnes choses. D'autres plus mauvaises.
Mon sentiment global c'est d'avoir perdu énormément de temps sur des choses qui ne m'apporteront jamais rien concrètement (théorie des langages quand tu nous tiens...). Je suis assez doué pour m'en sortir en faisant des impasses totales sur ce qui ne m'intéresse pas, donc j'y ai survécu.  Mais je pense pourtant qu'on m'a enseigné tous les éléments nécessaires pour pouvoir commencer à bosser sans avoir senti la moindre lacune. Je suis pas sûr d'avoir acquis à la fac des connaissances techniques hyper pointues (quoique j'ai fait énormément de c/c++ et un peu de J2EE/Delphi et survolé au total une bonne vingtaine de langages). Mais j'ai quand même l'impression d'avoir obtenu des bonnes notions de conception, d'algo, des connaissance du fonctionnement de la machine jusqu'au transistor, d'avoir appris où trouver de la documentation et comment se débrouiller avec, à défaut d'avoir appris chaque langage en profondeur.
Bref, le bilan est pas négatif. On peut à mon avis faire beaucoup mieux, mais c'est au moins suffisant.


----------



## Didier Guillion (15 Mars 2008)

grumff a dit:


> Je suis assez doué pour m'en sortir en faisant des impasses totales sur ce qui ne m'intéresse pas, donc j'y ai survécu.



Elle me plait celle la, je vais en faire ma devise... 

Cordialement


----------



## greensource (15 Mars 2008)

Bon bas moi je suis encore en plein dedans alors je vais essayer d'ajouter deux ou trois trucs 
Primo dans la fac ou je suis, mis à part 3 ou 4 cas les profs sont assez compétents, certains pêche quand même au niveau de la pédagogie ça c'est clair. Mais les vrais "incompétents" j'en ai recensé 2 et faut avoué que ça fait mal!
Sinon pour ce qui est des enseignements qui peuvent paraître inutiles je pense que c'est dû la une finalité recherche de l'université. J'ai l'impression qu'on est un peu dans un mix entre les écoles d'ingé et les Magistères. Du coup sans les cours de théorie des langages ^^ bas dur dur de savoir si tu veux en faire ton sujet de master  
Bon c'est qu'un exemple  mais comme ça reste une filière ou on doit "choisir" son orientation et bien je crois qu'il faut bien proposé tout un tas d'enseignement qui peuvent paraître inutile à certains.
Moi même aujourd'hui je ne sais pas exactement si je préfère faire de la recherche ou du développement.

Vous faites quoi exactement tout les deux?


----------



## grumff (15 Mars 2008)

greensource a dit:


> Bon bas moi je suis encore en plein dedans alors je vais essayer d'ajouter deux ou trois trucs
> Primo dans la fac ou je suis, mis à part 3 ou 4 cas les profs sont assez compétents, certains pêche quand même au niveau de la pédagogie ça c'est clair. Mais les vrais "incompétents" j'en ai recensé 2 et faut avoué que ça fait mal!
> Sinon pour ce qui est des enseignements qui peuvent paraître inutiles je pense que c'est dû la une finalité recherche de l'université. J'ai l'impression qu'on est un peu dans un mix entre les écoles d'ingé et les Magistères. Du coup sans les cours de théorie des langages ^^ bas dur dur de savoir si tu veux en faire ton sujet de master
> Bon c'est qu'un exemple  mais comme ça reste une filière ou on doit "choisir" son orientation et bien je crois qu'il faut bien proposé tout un tas d'enseignement qui peuvent paraître inutile à certains.


Le problème c'est que certains enseignements devraient être en option. Pas des options dont on est obligé d'en choisir 2 dans un lot de 3...



> Moi même aujourd'hui je ne sais pas exactement si je préfère faire de la recherche ou du développement.
> 
> Vous faites quoi exactement tout les deux?



Ingénieur d'étude et de développement dans une SSII.

On s'écarte pas mal du sujet, je vais en rester là pour ma part, j'ai déjà une trop grande tendance à foncer la tête la première dans tous les sujets qui peuvent être débattus...


----------



## greensource (15 Mars 2008)

Maintenant que mon TP marche aussi avec Xcode tu sais ^^ on peut dévier un peu, surtout que c'est intéressant.
C'est sur que de "vrai" options arrangerais pas mal de choses, je pense que c'est une question de moyen, ils ne veulent pas avoir 15 groupes de 5 étudiants, même si au final ça serais que du bonus pour nous.
Dans les écoles d'ingé c'est si différent? Ou bien c'est le même principe les trois premières années, que du bloc commun et ensuite spécialisation les deux dernières années?


----------

