KIFS is an acronym for Keep It Freakishly Simple.
Introduction
KIFS is not enumerable or objective. It is sensitive to the context with which it is to be applied. It is similar to the KISS philosophy but more specific. The goal of any software project developed using KIFS is simplicity in all aspects without affecting intended functionality.
KIFS is not exclusionary. It may be used within the user interface where something large, overbearing and wasteful like an MVC design pattern can be used for other aspects of a particular project. KIFS is there to help when needed.
Some advantages of KIFS are...
1) Using KIFS by nature brings the code to a more simple, easier to maintain level. Complex algorithms and logic can be developed using KIFS; and when it is, the resulting code should be comprehensible by most programmers familiar with the source language.
2) Program modules, files, functionality, UI and data will be separated into appropriately small and functional units.
3) There will be less fluff code, data and UI to support and maintain.
4) Performance in all aspects of a project or the part of a project developed using KIFS will be better than had KIFS not been used.
5) End users should experience a more streamlined UI and functional experience.
6) KIFS is Agile friendly and integrates well with the philosophical tenants of Agile.
Some disadvantages to using KIFS are...
1) Maintaining KIFS in a larger development team is more difficult than with a smaller team. Individually subjective opinions of 'simplicity' varies at an increasing rate relative to the size of the team. Because of this, certain 'simplicity' guidelines should be specified for any team and/or project. All people involved with the development need to be on the same freakin' page.
2) It may not embrace the leading edge of development. While a team or individual may be applauded for using KIFS, the general consumerism of the software development industry is somewhat counter to KIFS.
3) It is possible to take this concept too far. Simplicity, functionality, usability, performance and maintainability must all be evaluated to produce a viable, functioning piece of software using KIFS.
Some basic development and implementation guidelines for software developed under the KIFS philosophy...
1) Don't use images, special fonts, colors, sounds or other multimedia unless necessary. For example, I don't need a freakin' arrow on the freakin' website page telling me to scroll down to read more of the freakin' web page. I have about 5,000 books in my library and not a single freakin' one of them has printed at the bottom of every freakin' page, "turn page to read more."
2) Don't include functionality the will likely never be used. A word processing application doesn't need functionality to read the National Weather Service Current Conditions, translate them into any language the user wants and insert that onto the freakin' document I am working on. As a user, I don't freakin' want it. As a programmer, why support a functionality almost no one will freakin' use???
3) Keep your functional divisions within code manageably small. Don't shove all your web page logic into a single freakin' C# method! Split it up for freakin' sake! Each division shouldn't be more than a few printed pages. If each division could be equated to a paragraph in a novel, wouldn't you want to return a book that had 24 page-long freakin' paragraphs?
4) Critically analyze any desire or suggestion to include third party functionality, libraries or code, to perform minimal functions. You don't need to implement a freakin' library that exposes a freakin' web service that is read by a freakin' Javascript library on a web page just to customize the color of the freakin' header text!
5) Intelligently use a common function library, include file or repository. There is no freakin' way a web site should have twenty three freakin' FormatPhone() methods! Look in the freakin' common library. Don't have one? Think about making one... seriously.
6) Opt for using the smaller, more simple solution to a problem. Don't buy a huge freakin' software solution to perform a simple freakin' task. Delivering pizza with an F-16 fighter jet may seem pretty freakin' cool but an old Chevy El Camino is probably the better freakin' choice.
7) Critically analyze a project's data storage before implementation. Don't require the user to download an entire freakin' embedded database server to store 5k of configuration or log data.
8) Focus implementation on the core requirements and specifications of the system. Don't freakin' implement an entire spell checker on a web page when the users will have their own integrated spell checking installed.
9) Avoid newer technology and development methods. It's not about freakin' coolness, it's about getting the freakin' job done.
10) Use existing proven technologies when possible. Don't build your own freakin' communications protocol when all you need to do is retrieve vacation pictures from a web server.
11) Utilize your time wisely and optimally. Don't take a freakin' week to create a web page. If a freakin' login page takes you a week, it's too freakin' complicated.
12) Coordinate the definition of 'simple' within larger development projects. Some developers may think freakin' ASP is 'simple'. Others may think a DLL written in C is simple, while others may think PHP is better. The entire team needs to be on the same freakin' page!
---------
Please comment and add your own advantages, disadvantages and KIFS development guidelines here. Thanks for your freakin' time and consideration.
No comments:
Post a Comment