tus ejemplos distintos datos confusos conceptos concepto complejos claros blog analiza clearcase

clearcase - distintos - ejemplos de conceptos confusos



¿Cuáles son los conceptos claros básicos que todo desarrollador debe saber? (12)

Cómo usar git encima de ClearCase!

¿Cuáles son los conceptos básicos del sistema de control de versiones de Clearcase que todo desarrollador debe saber?

ClearCase es una bestia para usar. Lento, con errores y costoso. Algunas cosas que he hecho para enfrentar el uso de CC son:

  1. Siempre haga buenos comentarios cuando se registre.
  2. Use una especificación de configuración común y no la cambie muy a menudo.
  3. Nunca intente utilizar CC a través de una VPN o una conexión de red lenta.
  4. Apague la carga del médico CC al inicio.
  5. No mueva archivos a diferentes directorios.
  6. Programe al menos 2 minutos por archivo para registrarse.
  7. Las vistas de instantáneas son lentas, pero las vistas dinámicas son más lentas.
  8. Establezca el hábito de desarrollo de registrarse temprano y, a menudo, porque los archivos reservados y las fusiones son dolorosos.
  9. Haga que todos los desarrolladores revisen los archivos sin reservas de manera predeterminada.

Conceptos básicos ?

  • VCS centralizado (replicado) : ClearCase se encuentra a medio camino entre el mundo de VCS centralizado (uno o varios repos "centralizados" o VOBS - Bases de objetos de versión - cada desarrollador debe acceder al compromiso) y el mundo de VCS distribuido.
    Pero también admite un modo "replicado" que le permite replicar un repositorio en un sitio distante (MultiSite ClearCase), enviar deltas y administrar la propiedad. (las tarifas de licencia adjuntas son bastante abruptas)
    Este no es un verdadero modelo "descentralizado", ya que no permite evoluciones concurrentes paralelas: las ramas se dominan en una VOB u otra; solo puede registrarse en la VOB maestra para las ramas masterizadas allí, aunque tiene acceso de solo lectura a cualquier rama en cualquier réplica.

  • almacenamiento de versión lineal : cada archivo y directorio tiene un historial lineal; no existe una relación directa entre ellos como el DAG VCS ( Directed Acyclic Graph ) donde el historial de un archivo está vinculado al de un directorio vinculado a un commit.
    Eso significa

    • Cuando compara dos confirmaciones, debe comparar la lista de todos los archivos y directorios para encontrar el delta, ya que las confirmaciones no son atómicas en los archivos o directorios, lo que significa que no hay un solo nombre para todos los cambios en todos los archivos que componen un delta lógico

    • Eso también significa que una merge debe encontrar un merge común (no siempre el mismo que un ancestro común) a través de la exploración de la historia (ver siguiente punto).

      (Git está en el extremo opuesto de ese espectro, ya que está descentralizado y orientado al DAG:

      • si un nodo de su gráfico tiene el mismo "id" que un nodo de una confirmación diferente, no tiene que explorar más: se garantiza que todos los subgráficos sean idénticos.
      • la fusión de dos ramas es en realidad la fusión del contenido de dos nodos en un DAG: recursivo y muy rápido para encontrar un ancestro común)

texto alternativo http://publib.boulder.ibm.com/infocenter/cchelp/v7r0m0/topic/com.ibm.rational.clearcase.hlp.doc/cc_main/images/merg_base_contrib.gif

  • Combinación de 3 vías : para fusionar dos versiones, ClearCase debe encontrar un contribuidor común basado en su historial lineal, que puede ser bastante largo para el árbol de versión compleja (rama / sub-rama / sub-sub / rama, ...), y el comando de combinación ClearCase básico combina un archivo o directorio, pero no es recursivo. Solo afecta un archivo singe, o un solo directorio sin sus archivos ( ct findmerge es recursivo)

  • centrado en archivos (a diferencia del otro VCS más centrado en el repositorio): eso significa que la confirmación es archivo por archivo, no "conjunto de archivos modificados": la transacción está en el nivel de archivo. Una confirmación de varios archivos no es atómica.
    (Casi todas las demás herramientas modernas son "centradas en el repositorio", con una transacción de confirmación atómica, pero los sistemas de primera generación como RCS, SCCS, CVS y la mayoría de los otros sistemas anteriores no tienen esa característica).

  • id-managed : cada archivo y directorio tiene una identificación única, lo que significa que pueden renombrarse a voluntad: su historial no cambiará ya que la identificación permanece para el "elemento". Además, un directorio detectará en su historial cualquier adición / supresión de archivo. Cuando un archivo es "eliminado" ( rmname ), no lo sabe: solo se notifica al directorio y crea una nueva versión en su historial, con una lista de subelementos que no incluyen el archivo eliminado.

(Cree dos archivos con el mismo tamaño y contenido, obtendrán el mismo ID en Git, una clave SHA1, y se almacenarán solo una vez en el repositorio de Git. No es así en ClearCase.
Además, si se crean dos archivos con la misma ruta y nombre en dos ramas diferentes, su id es diferente significa que esos dos archivos nunca se fusionarán: se llaman " gemelos malvados ".

  • las sucursales son ciudadanos de primera clase : la mayoría de los VCS consideran que una rama y una etiqueta son iguales: un único punto en la historia a partir del cual puede crecer una nueva historia lineal (rama) o desde donde se adjunta una descripción (etiqueta).
    No es así para ClearCase, donde una rama es una forma de referenciar un número de versión. Cualquier número de versión comienza en 0 (solo se hace referencia en ClearCase) a 1, 2, 3, y así sucesivamente. Cada rama puede contener una nueva lista de números de versión (0, 1, 2, 3 nuevamente).
    Esto es diferente de otros sistemas donde el número de versión es único y siempre está creciendo (como las revisiones en SVN), o es único (como las claves SHA1 en Git).

  • Acceso a ruta : para acceder a una cierta versión de un archivo / directorio, necesita conocer su ruta extendida (compuesta por ramas y versiones). Se llama "nombre de ruta extendida": myFile@@/main/subBranch/Version .

(Git se refiere a todo a través de id - basado en SHA1 -: versión [o confirmación], árbol [o versión de un directorio] y blob [o versión de un archivo, o más bien de un contenido de un archivo]. es "id-access" o "id-referenciado".
Para ClearCase, una identificación se refiere a un "elemento": un directorio o un archivo, cualquiera que sea su versión.)

  • bloqueo pesimista y bloqueo optimista : (registros reservados o sin reserva en ClearCase): incluso un bloqueo pesimista (pago reservado) no es realmente pesimista, ya que otros usuarios pueden seguir comprando ese archivo (aunque en "modo no reservado"): pueden cámbielo pero tendrá que esperar que el primer usuario confirme su archivo (checkin) o cancele la solicitud. Luego fusionarán su versión de pago de ese mismo archivo.
    (Nota: un proceso de pago "reservado" puede liberar su bloqueo y el propietario o el administrador pueden dejarlo sin reserva)

  • ramificación barata : una sucursal no activa una copia de todos los archivos. En realidad, no desencadena nada: cualquier archivo no se mantendrá en su rama original. Solo los archivos modificados tendrán sus nuevas versiones almacenadas en la rama declarada.

  • almacenamiento de archivos planos : los VOB se almacenan en un formato propietario con archivos simples. Esta no es una base de datos con un lenguaje de consulta fácil.

  • acceso al espacio de trabajo local o de red :

    • el espacio de trabajo local es a través del proceso de pago en el disco duro ("actualización" de una vista de instantánea).
    • el área de trabajo de la red es a través de una vista dinámica, combinando archivos versionados y acceso a directorios a través de la red (sin copia local, acceso instantáneo) y archivos locales (los que están desprotegidos o los archivos privados). La combinación de archivos distantes (versionados) y locales (privados) permite que una vista dinámica aparezca como un disco duro clásico (mientras que en realidad cualquier archivo "escrito" se almacena en el almacenamiento de visualización asociado).

  • almacenamiento deportado centralizado : el almacenamiento [view] está ahí para guardar algunos datos y evitar algo o cualquier comunicación con el referencial central.
    un espacio de trabajo puede tener:

    • un almacenamiento disperso: como los subdirectorios .svn todo el lugar
    • un almacenamiento centralizado: al igual que el almacenamiento de la vista en ClearCase, contienen información sobre los archivos que muestra la vista, y ese almacenamiento es único para una vista.
    • un almacenamiento deportado: el almacenamiento no es parte de la vista / área de trabajo en sí, pero puede ubicarse en otro lugar de la computadora o incluso fuera de la LAN / WAN

(Git no tiene "almacenamiento" per se. ¡Su .git es en realidad todo el repositorio!)

  • orientado a metadatos : cualquier "valor clave" puede adjuntarse a un archivo o directorio, pero ese par de datos no se historiza por sí mismo: si el valor cambia, anula el valor anterior.

(lo que significa que el mecanismo es realmente más débil que el sistema de "propiedades" de SVN, donde las propiedades pueden tener un historial;
Git en el otro extremo no está muy interesado en metadatos)

  • protección basada en el sistema : el propietario y los derechos asociados con un archivo / directorio o repositorios se basan en la gestión de derechos del sistema subyacente. No hay una cuenta de aplicación en ClearCase, y el grupo de usuarios se basa directamente en el grupo existente de Windows o Unix (lo cual es bastante desafiante en un entorno heterogéneo, con clientes de Windows y un servidor de VOB de Unix).

(SVN es más parecido a la protección "basada en servidor", donde el servidor Apache puede obtener un primer nivel de protección, pero debe completarse con anzuelos para tener un grano de derechos más fino.
Git no tiene administración directa de derechos y debe ser controlado por ganchos durante el empuje o extracción entre repositorios

  • ganchos disponibles : cualquier acción de ClearCase puede ser el objetivo de un gancho, llamado disparador. Puede ser una operación previa o posterior.

  • CLI gestionado : cleartool es la interfaz de línea de comandos desde la que se pueden realizar todas las acciones.

De alguna manera fuera del tema, pero - No sé casi ningún desarrollador que esté contento con ClearCase. Me dijeron que debería tener características sofisticadas, pero como usuario de svn y git no puedo pensar en algo que extraño en git o subversión. Así que eso es algo que uno debería saber sobre ClearCase: la mayoría de los desarrolladores están muy contentos de trabajar con algo tan simple como subversion o git (sí, incluso git es más fácil de comprender), e incluso después de saber cómo completar las tareas más simples en ClearCase, tuve la constante sensación de que ClearCase trabaja en mi contra, no conmigo.

En mi opinión, la bifurcación y la fusión son los conceptos más importantes en cualquier sistema de control de fuente (al lado de las versiones, por supuesto).

Una vez que comprendas cómo se hace eso (y Clearcase lo hace muy bien, hasta el punto en que hacemos incluso pequeños cambios como una rama y vuelvo a fusionar, algo que nunca hubiera hecho con RCS o CVS), encontrarás tu vida se hace mucho más fácil.

Hay un comando muy útil que cleardescribe muchas veces. Se puede usar para obtener detalles de etiquetas y ramas. La sintaxis es:

cleardescribe lbtype:<LABELNAME>@/<VOB-NAME> cleardescribe brtype:<BRANCHNAME>@/<VOB-NAME>

Específicamente, esto le permite saber que la etiqueta se aplicó en qué rama y qué rama es la rama principal de una rama en cuestión.

He trabajado en varios proyectos medianos y grandes con éxito usando Clearcase y SVN. Ambas son excelentes herramientas, pero el equipo que las usa necesitan procesos documentados. Cree un proceso que describa cómo usará el sistema de control de versiones.

1) encuentre o cree un documento de mejores prácticas para su Sistema de control de versiones. Aquí hay uno para subversión , adáptelo a su proceso de Clearcase. Todos los desarrolladores deben cumplir con el mismo plan de juego.

Básicamente decida si va a ''siempre ramificar'' o ''nunca ramificar''.

Esquema Never Branch:

  • El esquema de nunca sucursales es lo que SourceSafe usa cuando los archivos están bloqueados durante el pago y están disponibles durante el registro. Este esquema está bien para pequeños proyectos de equipo (1 o 2 desarrolladores).

Esquema de la sucursal siempre:

  • El esquema de sucursal siempre significa que los desarrolladores crean sucursales para cada corrección de error o adición de función. Este esquema es necesario para proyectos más grandes, proyectos que tienen un lead (buildmeister) que maneja qué cambios se permiten en / main / LATEST en Clearcase o / trunk en SVN.
  • El esquema de sucursal siempre significa que puede registrarse a menudo sin miedo a romper la compilación. Su única oportunidad de romper la compilación es solo después de que su corrección de error o característica esté completa y la fusione a / main / latest.

''Branch when needed'' es un compromiso y puede funcionar mejor para muchos proyectos.

2) Con Clearcase (y Subversion) debe aprender a fusionarse, fusionarse es su amigo. Aprenda a usar las capacidades de fusión de Clearcase o use una herramienta como Beyond Compare o emacs-diff. Si su proyecto está bien modularizado (muchos pequeños archivos desacoplados), se beneficiará con menos (o ningún) conflicto durante la fusión.

3) Disfruta.

Hemos estado usando CC por más de quince años. Tiene muchas buenas características.

Todo nuestro desarrollo se realiza en las ramas; Creé un par hoy, para un par de diferentes series de cambios. Cuando me registré en la sucursal, conseguí que un colega revisara los cambios y luego me fusioné con / main / LATEST, que es donde debía ir mi trabajo. Si hubiera sido por una versión anterior en una rama, no habría sido más difícil.

Las fusiones de mis ramas temporales eran completamente automáticas; nadie había cambiado los archivos en los que trabajé mientras los revisaba. Aunque las cajas de pago predeterminadas están reservadas (bloqueadas), siempre puede cancelar la reserva más tarde o crear el pago sin reserva. Cuando los cambios tardan varios días, la resincronización de mi rama temporal con la rama principal es fácil y generalmente automática. El mergetool está bien; El mayor problema para mí es que mi máquina servidor está a unas 1800 millas más o menos de mi oficina (o mi casa), de modo que X sobre esa distancia es un poco lento (pero no tan intolerable). No he usado una herramienta de mezcla mejor, pero eso no dice mucho ya que no he usado ninguna otra herramienta de mezcla gráfica.

Las vistas (vistas dinámicas) son rápidas en nuestra configuración. No he usado vistas de instantáneas, pero no trabajo en Windows cuando puedo evitarlo (nuestro equipo usa vistas de instantáneas en Windows; no tengo claro por qué). Tenemos sistemas de ramificación complejos, pero el desarrollo principal se realiza en / main / latest, y el trabajo de liberación se realiza en una rama. Después de GA, el trabajo de mantenimiento se realiza en una rama específica de la versión, y se fusiona hacia adelante / principal / ÚLTIMO (a través de cualquier versión intermedia).

CC necesita buenos administradores: los tenemos y tenemos la suerte de hacerlo.

CC no es trivial de usar, aunque en este momento, encuentro ''git'' tan desalentador como lo es CC para aquellos que no lo han usado. Pero los conceptos básicos son muy similares: pago, cambio, registro, fusión, sucursal, etc. Los directorios pueden ser ramificados, con precaución, y ciertamente están controlados por la versión. Eso es invaluable.

No veo que la oficina cambie de CC en ningún momento.

Números de versión incrustados: ¿bueno o malo?

Escribí:

El mayor problema que tengo con CC es que no incorpora los números de versión en los archivos fuente, un problema que también tiene Git, AFAICT. Puedo ver a medias por qué; Sin embargo, no estoy seguro de que me guste abandonar esa capacidad de seguimiento. Por lo tanto, todavía uso RCS (ni siquiera CVS) para la mayoría de mi trabajo personal. Algún día, puedo cambiar a git, pero será una sacudida y requerirá mucho trabajo reorganizar los sistemas de lanzamiento configurados en torno a (SCCS y) RCS.

En respuesta, @VonC notas:

Siempre consideramos esa práctica como malvada (mezclando información de metadatos en datos), presentando "fusión del infierno". Consulte también Cómo obtener la versión del archivo Clearcase dentro de un archivo Java . Por supuesto, puede usar un disparador para la sustitución de palabras clave RCS ( Manual de Clearcase: Ejemplo de activación de Checkin ) siempre que utilice un administrador de combinación apropiado .

Hay varios problemas expuestos en esta discusión, y todos se mezclan. Mis puntos de vista rayan en lo arcaico, pero tienen un razonamiento detrás de ellos, y voy a tomarme el tiempo para escribirlos (desordenados por la vida; puede llevar varias ediciones completar esto).

Fondo

Aprendí SCCS en 1984, más o menos cuando se lanzó RCS (creo que en 1983), pero SCCS estaba en mi máquina y el internet era incipiente en el mejor de los casos. Me mudé de SCCS a RCS a regañadientes a mediados de los 90 porque el formato de fecha SCCS usa dígitos dobles durante años y no estaba claro si SCCS se fijaría universalmente en el tiempo (sí lo era). En algunos aspectos, no me gusta RCS tanto como SCCS, pero tiene algunos puntos buenos. Comercialmente, mi empleador usó SCCS hasta mediados de 1995, pero comenzaron a cambiarse a Atria ClearCase desde principios de 1994, abordando conjuntos de productos por separado de a uno por vez.

Experimento temprano de ClearCase con desencadenantes: fusionar el infierno

Nuestro proyecto migró más tarde, cuando ya había algo de experiencia con CC. En parte porque insistí en ello, incorporamos información de control de versión en los archivos fuente a través de un disparador de check-in. Esto duró un tiempo, pero solo un tiempo, porque, como afirma VonC, lleva a la fusión del infierno. El problema es que si una versión con la etiqueta / main / branch1 / N se fusiona con / main / M desde la versión base común / main / B, las versiones extraídas de los archivos contienen una sola línea que tiene ediciones en cada versión - un conflicto. Y ese conflicto debe resolverse manualmente, en lugar de ser manejado automáticamente.

Ahora, SCCS tiene palabras clave de identificación. Las palabras clave de identificación toman dos formatos, uno para los archivos que se editan y otro para los archivos que no se están editando:

Edit Non-Edit %I% 9.13 %E% 06/03/09 %Z% @(#) %M% s.stderr.c

Si intentó fusionar en 3 vías las versiones editables de los archivos SCCS (con la notación% x%), no habría conflictos en las líneas que contienen metadatos a menos que haya cambiado los metadatos en esas líneas (por ejemplo, al cambiar de US- estilo% D% fechas a% E% fechas estilo UK - SCCS no admite fechas de estilo ISO 2009-03-15 como estándar.)

RCS también tiene un mecanismo de palabras clave, y las palabras clave también tienen dos formatos, aunque uno es para archivos que aún no se han insertado en RCS y el otro es para aquellos que tienen:

Original After insertion $Revision$ $Revision: 9.13 $ $Date$ $Date: 2009/03/06 06:52:26 $ $RCSfile$ $RCSfile: stderr.c,v $

La diferencia está entre un ''$'' que sigue a la palabra clave y un '':'', espacio, texto, espacio y finalmente un ''$''. No he hecho suficiente fusión con RCS para estar seguro de lo que hace con la información de palabras clave, pero observo que si trataba las anotaciones ampliadas y ''contractadas'' como equivalentes (independientemente del contenido del material expandido), entonces la fusión podría tener lugar sin conflicto, dejando la notación contratada en el resultado de la fusión, que se expandiría adecuadamente cuando se recupere el archivo resultante después del registro.

El problema de ClearCase es la ausencia de un administrador de fusión apropiado

Como indiqué en mi análisis de SCCS y RCS, si se realiza la fusión tripartita tratando las palabras clave en los formatos correctos (contratados o editables), entonces no hay conflicto de fusión.

El problema con CC (desde este punto de vista -claramente, los implementadores de CC no están de acuerdo) es que carece de un sistema para manejar palabras clave y, por lo tanto, también carece de un administrador de combinación apropiado.

Si existía un sistema para manejar palabras clave y un administrador de combinación apropiado, entonces:

  • El sistema incrustaría automáticamente los metadatos en archivos en los marcadores apropiados.
  • Al fusionarse, el sistema reconocerá que las líneas con los marcadores de metadatos no entran en conflicto a menos que los marcadores cambien de forma diferente: ignoraría el contenido de los metadatos.

La desventaja de esto es que requiere una herramienta de diferencia especial que reconoce los marcadores de metadatos y los trata especialmente, o requiere que los archivos alimentados a la herramienta de diferencia estén canonicalizados (los marcadores de metadatos se reducen a la forma neutra - $ Keyword $ o % K% en términos de RCS y SCCS). Estoy seguro de que este poco de trabajo adicional es la razón por la que no es compatible, algo que siempre he considerado miope en un sistema tan poderoso. No tengo ningún apego particular a las notaciones de RCS o SCCS: las anotaciones de SCCS son más fáciles de manejar en algunos aspectos, pero son esencialmente equivalentes, y se podría usar cualquier notación equivalente.

Por qué todavía creo que los metadatos en el archivo son buenos

Me gusta tener los metadatos en el código fuente porque mi código fuente (a diferencia del código fuente de mi empleador) se distribuye fuera de la aegis del sistema de control de código fuente. Es decir, es principalmente de código abierto; lo pongo a disposición de todos y cada uno. Si alguien informa un problema en un archivo, especialmente en un archivo que han modificado, creo que es útil saber de dónde empezaron, y eso está representado por los metadatos originales en el archivo fuente.

Aquí, SCCS tiene una ventaja sobre RCS: las formas expandidas de las palabras clave SCCS son indistinguibles del texto regular, mientras que las palabras clave RCS siguen pareciendo palabras clave, por lo que si la otra persona ha importado el material en su propio repositorio RCS, sus metadatos reemplazan mis metadatos, un problema que no ocurre con SCCS de la misma manera (la otra persona tiene que trabajar para sobrescribir los metadatos).

En consecuencia, incluso si alguien toma un trozo de mi código fuente y lo modifica, generalmente hay etiquetas suficientes para identificar de dónde viene, en lugar de dejarme especular sobre la versión en la que se basa. Y eso, a su vez, hace que sea más fácil ver qué partes del problema soy yo y qué partes son de su creación.

Ahora, en la práctica, la forma en que funciona el código abierto, las personas no migran el código tanto como se podría pensar. Tienden a quedarse con la versión lanzada bastante de cerca, simplemente porque la desviación es demasiado costosa cuando se hace el lanzamiento oficial siguiente.

No estoy seguro de cómo se supone que debes determinar la versión base de un fragmento de código fuente que se originó en tu trabajo y que se ha revisado desde entonces. Sin embargo, encontrar la versión correcta parece ser la clave para hacerlo, y si hay huellas dactilares en el código, entonces puede ser más fácil.

Entonces, ese es un resumen moderado de por qué me gusta incrustar la información de la versión en los archivos fuente. Es en gran parte histórico, tanto SCCS como RCS lo hicieron, y me gustó el hecho de que lo hicieron. Puede ser una reliquia antigua, algo que se debe despedir en la era de DVCS. Pero todavía no estoy totalmente convencido de eso. Sin embargo, podría tomar aún más de un ensayo explicar los pormenores de mi mecanismo de gestión de lanzamiento para ver por qué hago las cosas como lo hago.

Un aspecto del razonamiento es que los archivos clave, como ''stderr.c'' y ''stderr.h'', son utilizados esencialmente por todos mis programas. Cuando lanzo un programa que lo usa, simplemente me aseguro de tener la versión más reciente, a menos que haya habido un cambio en la interfaz que requiera una versión de respaldo. No he tenido ese problema desde hace un tiempo (hice un cambio de nombre sistemático en 2003, eso causó algunos dolores de cabeza transitorios, pero los scripts de Perl me permitieron implementar el cambio de nombre con bastante facilidad). No sé cuántos programas usan ese código, en algún lugar entre 100 y 200 sería una suposición justa. El conjunto de cambios de este año (la serie de la versión 9.x) todavía es algo especulativo; Finalmente no he decidido si guardarlos. También son internos a la implementación y no afectan a la interfaz externa, por lo que no tengo que tomar una decisión por el momento. No estoy seguro de cómo manejar eso usando git. No quiero construir el código de la biblioteca en una biblioteca que deba instalarse antes de que pueda construir mi software, eso es demasiado oneroso para mis clientes. Por lo tanto, cada programa continuará distribuyéndose con una copia del código de la biblioteca (un tipo diferente de onerous), pero solo el código de la biblioteca que el programa necesita, no toda la biblioteca. Y escojo y elijo para cada programa qué funciones de la biblioteca se usan. Entonces, no estaría exportando un subárbol completo; de hecho, el compromiso que cubría los últimos cambios en el código de la biblioteca generalmente no está relacionado con la confirmación que cubría los últimos cambios en el programa. Ni siquiera estoy seguro de si git debería usar un repositorio para la biblioteca y otro para los programas que lo usan, o un repositorio común más grande. Y no voy a migrar a Git hasta que entiendo esto.

OK - suficiente wittering. Lo que tengo funciona para mí; no es necesariamente para todos. No exige nada extraordinario en el VCS, pero sí requiere metadatos de versión incrustados en los archivos, y CC y Git y (creo) SVN tienen problemas con eso. Probablemente significa que yo soy el que tiene problemas, suspensiones del pasado perdido. Pero valoro lo que el pasado tiene para ofrecer. (Puedo salirse con la suya porque la mayoría de mi código no está ramificado. No estoy seguro de la diferencia que supondría la división).

La forma de implementar las herramientas de control de versiones en su proyecto depende del tamaño y alcance de su proyecto y de la experiencia previa del equipo. ClearCase es una herramienta fantástica para grandes proyectos de desarrolladores y tamaño del proyecto. Administrar la sucursal es una de las perspectivas más importantes al usar la herramienta de control de versiones. sin ramificación y fusión, es una caminata de torta durante el ciclo de vida de su proyecto. Pero no puedes mantenerte alejado al fusionar por qué porque te permite bloquear y un fantástico desarrollo paralelo.

Si está utilizando ClearCase, asegúrese de utilizar el UCM que lo acompaña y los componentes compuestos.

Hace todas tus ramificaciones / fusiones sin esfuerzo. Estoy hablando de las principales ramas de reorganización que se ejecutan durante 6 meses que implican decenas de miles de cambios que incluyen cambio de nombre de directorio, cambio de nombre de archivo, etc. que resuelven automáticamente el 99.9% de los deltas.

Además, solo usamos vistas SnapShot, no vistas dinámicas. Nuestras vistas instantáneas se cargan más rápido de lo que puede arrastrar y soltar (Windows) el mismo árbol fuente desde una unidad de red.

La única queja que tengo sobre UCM es que la historia no puede abarcar los componentes. Si divide un componente en múltiples componentes nuevos, cada nuevo componente comienza en / main / 0.

Trabajé con clearcase durante la mayor parte de los 6 años y generalmente me pareció tolerable. Tiene una cierta curva de aprendizaje, pero una vez que te acostumbras a las peculiaridades, puedes trabajar sin problemas con ella. Un administrador de CC muy competente que sabe lo que hace es esencial para todo menos para configuraciones triviales. A menos que tenga uno, la gente tendrá problemas y pronto se hablará del problema de "ClearCase". Luego, la gerencia tendrá que intervenir cambiando a otra cosa que solo ocasionará pérdida de tiempo para todos los involucrados. CC no es un mal producto, a veces es poco conocido.

Aquí hay algunos conceptos que considero importantes, algunos de ellos no están claramente orientados solo a CC:

  • Un check-out es diferente a la noción habitual de CVS de un check-out. Cuando salga, bloqueará el archivo hasta que lo registre.
  • No hay problema con mover archivos. De hecho, esto funciona a la perfección.
  • Los árboles de versión son esenciales para comprender lo que le ha estado sucediendo a un archivo. Pueden ser bastante complicados para los archivos activos, pero cuando te acostumbras a verlos se convierte en una herramienta muy útil y en una que falta en otras herramientas de control de fuente como SVN (hasta cierto punto).
  • No use vistas dinámicas bajo ninguna circunstancia. que no vale la pena.
  • Antes de crear una nueva sucursal, transmisión o proyecto, asesórese con su administrador para asegurarse de que lo que cree realmente sea lo que le servirá mejor. Al comenzar una nueva base de código, asegúrese de obtener las secuencias y el diseño de los proyectos desde el principio mediante la planificación anticipada. cambiarlo más tarde es un verdadero dolor de cabeza si es posible.
  • Ajuste los privilegios de los usuarios y configure los desencadenantes de eventos comunes para evitar errores comunes o aplicar políticas. El servidor es muy configurable y la mayoría de los problemas que encuentre probablemente sean una solución razonable.
  • eduque a los desarrolladores sobre cualquier cosa, desde conceptos básicos hasta operaciones avanzadas. Un usuario avanzado que puede descubrir cuál es el problema al usar cleartool disminuye la carga sobre el administrador.
  • No deje corrientes ni vistas colgantes. Cuando un desarrollador se va del proyecto, tenga a alguien que elimine todas las vistas que tenía en su máquina y elimine todas sus transmisiones privadas. Si no mantienes tu servidor limpio, resultará en que estará sucio y, con el tiempo, será lento. Cuando haces un "buscar todos los registros" en todas las transmisiones y vistas, no deberías ver los archivos que son retirados por personas que ya no existen.
  • Ordene una política de "siempre rebase antes de entregar" para sucursales secundarias para evitar que las personas "rompan la secuencia de integración" cuando entregan código que entra en conflicto con cambios recientes.
  • Integración continua : no permita que la secuencia de integración se estanque mientras cada desarrollador o equipo trabaje en su propia sucursal. Mandato una vez cada X vez que todos tengan al menos que rebase a la base de referencia de integración más reciente si no es para entregar sus cambios estables. Esto es realmente muy difícil de hacer, especialmente con proyectos grandes, pero la otra alternativa es el "infierno de la integración", donde a fin de mes nadie hace nada durante 3 días, mientras que un pobre pobre trata de encajar todos los cambios.