Is this right way to implement Abort, Retry and Ignore activity pattern?

What is the best way to implement a new UI pattern library within a large existing codebase?

• I'm currently working within a large codebase (a crm) that has developed very rapidly over the past several years. No initial pattern libraries were set, and so the system has been built with a vast array of CSS inconsistencies concerning layout, type, style, and so on. As the product is in use, no sweeping style changes can be done initially (i.e. the entire system being restyled and then shipped) as users could get confused, and also many devs/designers cannot take a month or so to solely work on this project. My question is, concerning these restraints (time, money, and a large system chock full of spaghetti CSS) what is the best route to implement a ui pattern library over this codebase?

• Answer:

  Refactoring inside of a large established code base is always a challenge. Everything you want to change turns out to have other code dependent on it. So you are constantly faced with either unanticipated quality/breakage problems or wild scope creep that makes any small change into a large change. The most interesting (and simple) approach that I've seen to this is the Mikado Method. Find something you'd like to improve and start to naively make changes to enact the improvement. As soon as you figure out that something else is dependent on it, you add it to a dependency graph, and revert what you've done. Target your optimization to the new end points and repeat. The goal is to find the outermost fringes of the code effected by a desired refactor and fix things from the outside towards the inside until you get to the heart of the problem. You are probably also thinking about the inconsistency of some of the app being restyled while other parts are not. Implement a consistent and compatible set of design patterns and styles that are compatible with the existing look. You will not get to redesign things as deeply as you would like, but a consistent set of styles based on clean code is still a massive improvement in terms of the UX, the maintainability of the app. Think about deeper redesigns in the future against consistent design patterns and a clean code base. Your ability to redesign deeply AFTER you have cleaned things up will be vastly improved. (a) It will be easier to see how to make UX improvements on something that's more rational. (b) You will be able to execute a redesign in less time and therefore with less merge problems against other ongoing changes. (NOTE: I'm not affiliated in any way, but I have found it interesting enough to apply their basic concepts.) http://mikadomethod.wordpress.com/2009/12/09/introduction-to-the-mikado-method/#more-1 The best way to learn about it right now (since their book isn't out yet) is to watch some videos: https://www.google.com/search?q=the+mikado+method&rlz=1C1GPCK_enUS441&oq=the+mikado+method&aqs=chrome..69i57j69i65j69i60j69i64l2.1849j0j7&sourceid=chrome&ie=UTF-8#q=the+mikado+method&safe=off&tbm=vid http://mikadomethod.org/