Go Immutable,
Go Serverless,
Go Stateless,
Go Single thread,
Go Fail Fast,
Be Agile

=>

Get HA, (Load Balancing, Fault Tolerance, Resiliency)
Get Elastic Grow, (High Scalability)
Get Distributed Deploy,
Get Modularity,
Get Infrastructure Usage Optimization

When asking a question about a problem caused by your code, you will get much better answers if you provide code people can use to reproduce the problem. That code should be…

…Minimal – Use as little code as possible that still produces the same problem
…Complete – Provide all parts needed to reproduce the problem
…Verifiable – Test the code you’re about to provide to make sure it reproduces the problem

Minimal

The more code there is to go through, the less likely people can find your problem. Streamline your example in one of two ways:

Restart from scratch. Create a new program, adding in only what is needed to see the problem. This can be faster for vast systems where you think you already know the source of the problem. Also useful if you can’t post the original code publicly for legal or ethical reasons.
Divide and conquer. When you have a small amount of code, but the source of the problem is entirely unclear, start removing code a bit at a time until the problem disappears – then add the last part back.

Minimal and readable

Minimal does not mean terse – don’t sacrifice communication to brevity. Use consistent naming and indentation, and include comments if needed to explain portions of the code. Most code editors have a shortcut for formatting code – find it, and use it! Also, don’t use tabs – they may look good in your editor, but they’ll just make a mess on Stack Overflow.
Complete

Make sure all information necessary to reproduce the problem is included:

Some people might be prepared to load the parts up, and actually try them to test the answer they’re about to post.
The problem might not be in the part you suspect it is, but another part entirely.

If the problem requires some server-side code as well as an XML-based configuration file, include them both. If a web page problem requires HTML, some JavaScript and a stylesheet, include all three.
Verifiable

To help you solve your problem, others will need to verify that it exists:

Describe the problem. “It doesn’t work” is not a problem statement. Tell us what the expected behavior should be. Tell us what the exact wording of the error message is, and which line of code is producing it. Put a brief summary of the problem in the title of your question.

Eliminate any issues that aren’t relevant to the problem. If your question isn’t about a compiler error, ensure that there are no compile-time errors. Use a program such as JSLint to validate interpreted languages. Validate any HTML or XML.

Ensure that the example actually reproduces the problem! If you inadvertently fixed the problem while composing the example but didn’t test it again, you’d want to know that before asking someone else to help.

It might help to shut the system down and restart it, or transport the example to a fresh machine to confirm it really does provide an example of the problem.

Hay muchas formas de hacer Software.
Nosotros estamos obsesionados encontrando a la mejor.

Hola !

Cognición es la facultad de procesar información a partir de la percepción, el conocimiento adquirido (o experiencia) y a características subjetivas que permiten valorar la información.

De lo anterior, un proceso cognitivo nos permite evaluar dimensiones, tiempos y complejidades a través de mecanismos no necesariamente científicos, pero que no por ello pierden validez y vigencia. Mecanismos heurísticos.

Según el matemático George Pólya, la base de la heurística está en la experiencia de resolver problemas y en ver cómo otros lo hacen. Consecuentemente se dice que hay búsquedas ciegas, búsquedas heurísticas (basadas en la experiencia) y búsquedas racionales.

Un problema que sobreviene frecuentemente, es tener el deseo de establecer un marco sistemático para todo proceso humano, incluido el del desarrollo de software, siendo que en esta área, intervienen una gran cantidad de factores heurísticos que requieren del uso de nuestras capacidades cognitivas.

En su base mas fundamental, el levantamiento de requerimientos tuvo necesariamente que requerir de nuestra capacidad de análisis personal dado que a la fecha, no existen mecanismos sistemáticos cerrados y concretos para su obtención.

De la misma forma, aunque mas atenuada, ocurre algo similar con el cálculo de tamaños y tiempos que, si bien, se ha llegado a sistematizar en cierta medida, con el uso de estadística y la definición de estándares métricos, en diversas ocasiones, durante la práctica, se ha observado que es mas productivo efectuar un consenso COGNITIVO grupal para determinar “el peso” de elementos que involucran complejidad y tamaño como un todo y no a través del análisis estadístico y muestral de cada característica por separado.

Durante el análisis de la correctéz de un algoritmo o de un diagrama arquitectónico, nuevamente se requiere de heurísticas para determinar si tales productos son apropiados o no.

Y durante la creación del producto, la creatividad es el ingrediente principal que tiene como objetivo, resolver el o los problemas “de negocio”. Esto debido a que las piezas de creación automática, bajo ninguna circunstancia, podrán tener “inteligencia” alguna.

Y finalmente, durante las las pruebas, la selección correcta de un escenario de prueba tiene necesariamente que involucrar nuestra capacidad cognitiva y nuestras técnicas heurísticas para lograr proponer escenarios concretos, adecuados y realmente útiles.

Cabe mencionar que en la actualidad, existen metodologías que explotan la capacidad cognitiva en algunas de sus áreas, como por ejemplo, SCRUM en su técnica de ScrumPoker para el dimensionamiento de “pesos” asociados a tareas.

Con base en lo anterior, suena sensato siguerir la inclusión de prácticas cognitivas concretas en cada una de las fases de un proceso de desarrollo y el uso de técnicas heurísticas que se han madurado al interior de cada individuo, para dar origen a lo que personalmente llamo “Desarrollo Cognitivo” o CDD si se prefiere del inglés, “Cognitive Driven Development”.

Saludos,
Goose

P.D. Dejo una reflexión de Steve Freeman:

Just in case you missed that (and it took me a while to see it), it makes a cognitive difference whether you write the tests first or the code…”
Taken from:

http://www.higherorderlogic.com/2008/06/test-driven-development-a-cognitive-justification/

1) En todos lados hay reglas. Asegúrate de seguirlas.
2) Primero entiende el problema. Después, resuélvelo. Después codifícalo.
3) Ama a tu código como a ti mismo.
4) Trata de reutilizar todo lo que puedas.
5) El código generado automáticamente es generalmente mejor que el código hecho a mano. Procura al primero sobre el segundo.
6) Documenta todo: Tiempos, problemas, soluciones, peticiones, sugerencias, código, etc., etc.
7) Mantente vigente en cuestiones tecnológicas y avances en tu plataforma.
8] Experimenta, inventa, sugiere, debate.
9) Se constante y disciplinado en cada cosa que hagas.
0) Rodéate de gente capaz y escucha lo que dicen.

Atte,
Goose

El presente post está basado en el artículo de Oracle siguiente:

http://java.sun.com/blueprints/code/projectconventions.html

Su nombre lo dice todo: “Project Conventions”

Traté de generar un pdf del artículo, aunque salió un poco extraño…
Pueden intentar ver el pdf aquí.

Por otro lado, me gustaría incluir algunos gráficos que hablan por si solos:

Aquí va otro muy chido:

Espero que esto le sirva a alguien de algo….

Saludos,
Goose

Hace algunas horas, al depurar uno de mis discos duros, encontré un trabajo que realizó un amigo mío, durante su estancia en la escuela en donde ambos hicimos la maestría: El IIMAS.

Aún hoy en día, con todos los cambios que ha sufrido CMM el trabajo de Francisco Noguez me parece claro, concreto, puntual y preciso.

El siguiente enlace nos llevará a un sitio de disecta el CMM II de hace 10 años, cuando AJAX y todo lo nuevo para web 2.0 no existía. Sin duda un visionario de la usabilidad web y como muestra, este sitio que está hecho con html y jScript al 100%. Una labor de filigrana, un trabajo claramente de maestría. Gracias, Paco.

http://www.gustavo-arellano.com/cmm2/index.html

Tal y como el título lo indica, a continuación voy a republicar una página que encontré en donde aparece una gran lista de herramientas para modelado de UML que originalmente publicó una persona de nombre Michael W. Godfrey.

La dirección original de publicación es: http://plg.uwaterloo.ca/~migod/uml.html



My Little UML (Tools) Page

Background and Context

I (and others) teach a course in software requirements at the University of
Waterloo. For Fall 1999, we switched notations from OMT to UML, and we
went looking for a reasonable UML tool. We had been using Software Through
Pictures (OMT version) but we were unhappy with its reliability and general
usability.

Our primary requirements for the new UML tool were

  • that it should support most UML analysis diagrams (class, use-case,
    collaboration, sequence, and activity),
  • that it be easy to use, reliable, scalable,
  • that it be free or almost free to universities, and
  • that there be a free-ish Windows and/or Linux version that students may
    install on their home machines.

Second-tier requirements included that the tool should run on our Solaris
boxes, since we have relatively few PCs running Windows. We found that
some of the tools below have Unix ports, while others are “pure Java”.

We did not require support for features that many CASE tools
provide, such as UML design diagrams, or for reverse engineering or code
generation. All of these factors bear on the comments below. Your mileage
may vary depending on your own requirements!

Disclaimer
The views on this page are personal opinions. I have not accepted and will
not accept money, favours, or similar rewards for comments on any tool
mentioned on this page. Some of the vendors below have given me free
versions of their software to try out, but that’s it.

 

What tools do *I* use?

Currently (summer 2005), I use OmniGraffle for simple UML diagrams, and I
use MagicDraw for more complex diagrams, where the underlying model needs
to be represented explicitly.

Some open source tools

  • Modelling tools:
    • Gaphor, a GPL modelling tool written in Python using GTK+ (and so will run on *nix, MacOS, and Windows with Python and GTK+ installed). Currently [June 2007], it supports class, component, action/activity, and use case diagrams, with sequence and collaboration diagrams coming “soon”. The tool emphasizes drawing UML diagrams, rather than application generation.
    • Umbrello, a GPL modelling
      tool that looks interesting, tho I have taken it for only a short test
      drive. Runs under (requires) KDE and Linux. Also supports code
      generation as well as reverse engineering (code to UML) for C++ and
      Java. Their grand goal is “to reach a deep integration with other KDE
      development tools to create an unique development platform”.
    • Astade is aimed at aiding in
      autogenerating C++ source from UML models. It is meant to be practical
      rather than research oriented. Currently, it can serve as a front end
      to GCC. It is early days in its development as of November 2005. An
      installer is available for MS-Windows, or you can compile up the
      sources yourself under Linux.
    • FUJABA (the
      rather unlikely acronym stands for Forward Unto Java And Back Again),
      supports both reverse engineering of and code generation for Java
      systems. It’s a research system (released under the LGPL), that
      supports UML class and behavioural diagrams. Disclaimer: Some of the
      past and present FUJABA project members are pals of mine (Hi Jens,
      Albert, Jörg). 
    • ArgoUML, a free research
      modelling tool; fairly fully featured; the main goal is to have a
      Really Useful user interface, unlike almost all existing CASE tools;
      there are some nice UI ideas in here; I encourage you to take it for a
      test drive and consider joining in on the development. Note that there
      is a commercial version of this tool that goes by the name Poseidon and
      is marketed by a Gentleware;
      they offer a free community edition as well as fancier editions that
      cost real money. 
    • Coral is an open source
      research-based modelling and meta-modelling tool, from �bo Akademi
      University in Finland. It can be used to develop new modeling
      languages or as a platform to construct other modelling tools. It
      implements OMG standards such as MOF and UML into an extensible
      framework that can be customized to a final application. 
  • Drawing tools:
    • DIA, a freeware/GPL
      multiplatform (!!) drawing tool based on GTK; supports UML and other
      kinds of diagrams; this is intended to be a freeware Visio-like drawing
      tool rather than a modelling tool; I have a few UI quibbles, but
      overall this looks like a very nice drawing tool; DIA now comes
      standard with many Linux distributions. There are now also
      easy-to-install versions for Windows and OSX (since the port of GTK to
      those OSs made this possible). [updated Feb 2007]
    • Violet, a very simple GPL
      drawing tool written by Cay Horstmann (who has written many nice books
      on programming in C++ and Java; I’ve used two of them in courses I’ve
      taught). Pretty much all of the comments on UMLet below apply to
      Violet, as it’s pure Java (single jar file) and very simple to
      use/learn. The Violet UI is different tho; try both and see which you
      like more. 

      (Roses are Rational, violets are GNU, … get it? OK in light of
      recent events, I guess that roses are (big) blue now too.)

    • UMLet, a small, very simple, and
      easy-to-use drawing tool (as opposed to a fully fledged modelling tool)
      from the Technical University of Vienna. It’s free for educational and
      non-commerical use. While it’s pure Java, the jar file is so small
      (v1.0 is less than 60K) that it should run well for most people. This
      tool would work very well for classroom use since students can download
      their own copy and it’s so simple (and customizable), there’s no real
      learning curve. This tool will not scale up to heavyweight modelling
      of big systems, but it isn’t meant to. 

Some commercial tools
that support UML diagrams that I’ve at least had a look at
 

  • Modelling tools:
    • MagicDraw, a commercial tool;
      pure Java and will run on Windows / MacOS X and most Unix variants.
      Downloadable free community edition; more expensive editions give
      fancier features. It is very fully featured, and even compliant with
      the latest UML standard, if that matters to you. A nice piece of work. 

      • Update Fall 2004 — UWaterloo has decided to get
        a site license for MagicDraw for use in various courses, including
        the software requirements course I teach sometimes. I’ve been
        using MagicDraw quite a bit recently, and I like it. If you are a
        UWaterloo person, you can download our current licenced version here.
    • IBM Rational Rose, perhaps
      the best known UML tool; free to universities (if you ask), but it has
      a reputation for being awkward and buggy. I have not used it seriously
      since version Rose98i, so your mileage may vary (maybe it’s improved!).
      Rational was been bought by IBM severl years ago, but I’ll bet you knew
      that already. 
    • astah* (formerly known as JUDE) has a free community edition that supports basic UML diagrams. There are also commercial editions: astah* UML supports basic UML diagrams and Mind Map with import/export Java, export C#, C++ functions. astah* professional is a unique system design tool which supports UML, ER Diagram, Flowchart, CRUD, Data Flow Diagram (DFD), Requirement Table and Mind Map. astah* developed in Japan, and supports both English and Japanese. To share diagrams on web browser, astah* share is available. [Updated Oct 2009]
    • Together, a
      commercial tool; pure Java; full version can be had for free for
      academic use; worked well for my limited needs when I tried it out in
      the summer of 2001. At some point since then, the Together suite was
      acquired by Borland. 

      • The comments on this tool are so out of date, that
        my original (correct) link now
        redirects you to a page on Peter Coad’s technique for learning
        biblical Greek.
  • Drawing tools:
    • OmniGraffle
      is a drawing tool that comes bundled with new Macs (at least it
      did in Spring 2005 when I bought my first Powerbook). It’s a drawing
      tool, not a modelling tool, but it does include some UML stencils. I
      have found it to produce the
      nicest
      looking
      UML diagrams of any tool I have tried so far, and it is
      currently my tool of choice for simple UML diagrams (I use MagicDraw
      for more complicated ones). It runs on MacOS X only. A “pro” version
      is available for a little more $$$; the pro version can also be used
      to do Powerpoint-like presenatations (i.e., multi-”canvas”
      documents, not just single diagrams).
    • Visio, designed to
      be a top notch commercial drawing tool, rather than a reverse
      engineering or modelling tool per se. The level of support for UML
      diagrams has varied over the years, depending on which version you
      purchased, so be sure to check out the most recent web page if you are
      interested in using Viso for UML diagrams. Viso was bought out by
      Microsoft in 1999, but you knew that too, right? 

      • It may be possible to add This
        Visio stencil
        to the cheaper versions; that is, the stencil
        lets you draw vanilla pictures that look like UML but doesn’t give
        you fancy cross referencing between diagrams;
  • Cetus (see below also) has
    an excellent page on
    OOA/OOD
    tools
    , including (ahem) a link back to this page. 

Other UML Tools
I haven’t looked at much (because I don’t have time and frankly I doubt I will
anytime soon), but the author/company that made them shamelessly asked me to add
them to my list anyway

No endorsements implied for these tools; I haven’t looked at ‘em seriously.

  • gModeler is, well, a little
    different. It’s a free online tool for drawing UML class diagrams. It’s
    written in FlashMX (!!). I’m not sure how useful it is, but it does have a
    certain “wow that’s cool” factor to it. It runs in any Flash-enabled web
    browser (I used Galeon under Linux).
  • Steve Hanov, currently (March 2007) a graduate student in my department, has created a web-based sequence diagram generator. It takes simple textual input and creates a sequence diagram you can snarf. The service is free, but the project is not open source.
  • Rhapsody (by
    iLogix, an OMG member) is meant to be a competitor
    to Rational Rose, supporting model-driven development and all those
    good things. A 30 day trial download is
    available
    . They also appear interested in university licences. 
  • Modelistic supports UML class
    diagrams only, reverse engineered from Java code. It’s based around
    IBM’s Eclipse platform. The idea
    (they claim) is that you can define your own sets of Java model
    elements, which you then use as filters for controlling how things are
    displayed, and this makes for a powerful Java analysis / visualization
    tool.
  • Visual
    Thought
    is an apparently dead diagramming tool that has been
    released as freeware. It’s meant to be a competitor to, say, Visio but
    specializing in software diagrams. 
  • EclipseUML from Omondo is a
    visual modelling tool for Java, natively integrated with Eclipse and
    CVS. It implements all UML diagrams. They claim to support model
    driven development using live bidirectional code and model
    synchronisation, database and J2EE. They have a stripped-down free
    version and a time-limited fully featured version for download. 
  • UMLStudio is a commercial tool
    supporting UML and other notations (including user-defined ones). It
    supports code generation and reverse engineering of C++ and Java. 
  • SmartDraw is meant to be a
    competitor for Visio (i.e., it’s a drawing tool rather than a
    modelling tool). It appears only the most expensive Pro version will
    support UML, tho the company indicated to me that they might be willing
    to do a special deal for universities. It runs on Win32 platforms
    only. 
  • MetaEdit+, which seems like
    it is a “forward” engineering tool for editing design of methods. It
    claims to be both a CASE and a meta-CASE tool in that you can plug in
    your own subcomponenets. It supports UML plus several other notations.
    It runs on Win32 and several Unices, and the Linux version is “free for
    non-commercial use” (October, 2003)

  • Select Component Architect
    specializes in UML support to aid in
    component-based design (CBD) and business system design. Apparently,
    this tool suite has been around for over 10 years; previous names
    include Select Enterprise and Select OMT Professional (August
    2003)
    .
  • Visual Paradigm for the
    Unified Modeling Language
    (VP-UML) is a UML CASE suite that
    supports Java code generation; as of Jan 2002, a free beta is
    available.
  • EctoSet Modeller,
    according to its developer, is a Windows-based UML tool with scripting
    for forward engineering. Scripts are provided for generating Delphi,
    C++Builder, Java and VB code. Available in Professional and Standard
    versions, plus a free read-only viewer.

  • ProxyDesginer
    by ProxySource.com is a free
    PC-based tool for creating and sharing UML software designs.
  • JVision is a commercial tool
    intended to help reverse engineer (and then presuambly re-engineer)
    Java source code libraries into UML diagrams; demo downloadable. 
  • iUML from Kennedy-Carter claims “Intelligent
    support for Executable UML”
    and runs on NT and Unix. A free “lite”
    version is available.
  • Embarcadero
    Describe
    , a commercial tool formerly known as GDPro.
  • WithClass is “a UML tool that runs under Windows (supports C++,
    Delphi, Java, VB, IDL)”
    from MicroGold
  • WinA&D
    and MacA&D
    from Excel Software claim to
    be the only fully compliant UML tools for both Win and Mac platforms;
    their translator tools can generate UML class models from C++, Java or
    Object Pascal.
  • HAT (HOORA
    Analysis Tool)
    provides support for UML using the HOORA process,
    and claims to support Rose model imports, automatic diagrams (static
    model, dynamic model, package summary), requirements management and
    traceability, hierarchy support, dictionary support, Word documentation
    generation, C++ code generation, COM interface, and more. 
  • ObjectDomain a commercial
    tool; claims to support full UML; written in pure Java; demo
    downloadable.
  • Visual UML, a commercial
    tool.

CASE Graveyard

The following UML tools seem to have died.

  • SequenceSketcher is a MacOS-X
    application for drawing sequence diagrams only.
  • Object Technology Workbench
    according to their website, this tool provides “round-trip
    engineering and code generation, and integrates visual modeling into
    the entire development process.”
    Win32 platforms only [the tool seems to
    have died while the website lives on as a consulting group]
  • Object Engineering Workbench, or OEW,
    a commercial tool; modelling tool seems to be freely downloadable but
    extra features cost real money; all UML diagrams are supported in the
    free version; UI not as good as Rose but supports more of UML
  • FreeCASE, a freeware OO
    CASE tool that seems to be in very early development

Selected Feedback on
this page

  • … can be found here.

Some more UML
information


 


Michael W. Godfrey PhD, Associate Professor,

David R. Cheriton School of Computer Science,
University of Waterloo

Waterloo, Ontario, N2L 3G1, CANADA

Tel. +1 (519) 888-4567 ext. 34437, FAX +1 (519) 885-1208

Office: DC2340

email:

URL: http://www.uwaterloo.ca/~migod


 

© 2017 Goose Workshop Suffusion theme by Sayontan Sinha