Principles Wiki

User Tools

Site Tools

You are here: Principles Wiki » principles » keep_it_simple_stupid
principles:keep_it_simple_stupid

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
principles:keep_it_simple_stupid [2025-11-25 10:53] – old revision restored (2021-10-20 21:09) christianprinciples:keep_it_simple_stupid [2025-12-20 11:30] (current) – created maritzatreacy
Line 1: Line 1:
-====== Keep It Simple Stupid (KISS) ======+Submit site to online search engine directories. Don't overlook the smaller search engines; they may reach a market market which ideal for what your site has offer. You can also post comments on different blogs and insert your website into the comment. Make sure you write something is actually not useful so as to avoid looking like those awful spammers. A good method to find these blogs is by typing a keyword of yours in a search engine like Google and then typing "post comment". Write that in parenthesis. Here's and example: acupuncture "post comment".
  
-===== Variations and Alternative Names =====+Why a lot of? And traditional counseling the numbers seem in order to increasing? Several reasons exposed to mind. One, on average we are living longer. Problems that used to result in death are presently more treatable, extending our lifetimes. And with longevity will come chronic pain related to these conditions just to the maturing process. Another reason for the increase in our pain could be the increase in obesity in the United Levels. According to the Centers for Disease Control (CDC), as of 2009 only two states had an obesity rate of compared to 20%: the District of Columbia and Colorado (Centers for Disease Control and Prevention, 2009). The CDC reports that obesity quite often to diseases that contain chronic affliction.
  
-  * (Rule of) Simplicity +The Intern told me to Osteopathic clinic have a sip of water. It was about 7 hours into the process and i had tried that ahead of time. It sent me into a coughing, hacking tailspin. She insisted, annoyed at her inability to pay attention I chugged the water she held as she stood silently for the next five minutes, looking quite embarrassed due to the fact hacked my guts out side.
-  * KISS may also mean "Keep it short and simple", "keep it simple and straightforward", "keep it smart and simple", etc. A large amount of variations exists.+
  
-**Remarks**: "Stupid" may be interpreted as an adjective or a noun. Compare the two variants "keep it simple and stupid" vs. "keep it simple, stupid!". Despite all these alternative names, the general idea of the KISS principle is always the same.+As the healthcare reporting system is run on a normal PC, installation and maintenance costs could well be kept as low as possible. You won't need dedicated support staff on hand to draw you through every little facet. You'll just be able to get on with serving the needs of your victims.
  
 +If you've been watching the Democratic primaries you probably know each of the candidates have introduced their universal healthcare policies. All of those who might be Christ Jesus need figure out this very clearly. There exists a much better healthcare system, because our leader is not subject alter because of a false accusation, or an exit poll change. Our leader has given us His policy where health is alarm. The blessing of His redemptive name Jehovah Rapha (I Am the Lord theat Healeth Thee) was provided by the Atonement. It was His first promise to heal.
  
-===== Context =====+As application runs on desktop pcs, the [[http://cgi.www5b.biglobe.Ne.jp/~akanbe/yu-betsu/joyful/joyful.cgi?page=20|宮崎市 交通事故治療]] reporting system is easy to locate out and use, and appears like familiar product. This encourages people to use it, and same goes with be efficient.
  
-  * [[contexts:Object-Oriented Design]] +Our birthrate is now lower in comparison with previous several. This means right now there are fewer of us coming along to spend cost for my family as we age. You need to seen the figures about number of folks paying into government programs Osteopathic clinic shrinking. All the while, the number of us receiving benefits is booming. Does child Boomer Generation ring a bell? Yet we are better off than many other countries facing the same challenges.
-  * [[contexts:Architecture]] +
-  * [[contexts:User Interface Design]] +
-  * [[contexts:Implementation]]+
  
-===== Principle Statement =====+Effectively using relationship marketing in your Acupuncture clinic will even go into developing your USP (unique selling proposition). Most businesses, big and small, are able to focus lots of their attention on sales and being nice towards the person who's giving serious cash.
  
-A simple solution is better than a complex one, even if the solution looks stupid. +There differ kinds of careers which individuals choose these days. One of the most popular industries may be the health care industry. Some individuals want to try a job in 宮崎市 交通事故治療 the health care markets. If you are interested in these a job then usually make sure that you ready yourself for this career.
  
 +I think everyone would agree that lowering healthcare costs is really a really cool idea. Before we ask (or allow) the government to take on the entire industry, once in a while want to think about at it little much closer.
  
-===== Description =====+Physician Assistant - Being a PA can be a great way to get a high-paying job (think over $70,000 annually!) while getting great job security. In order to are a PA, you will need a Bachelor's degree, along with other program. Physician Assistants can help diagnose and prescribe medication to patients, making them one of the most necessary additions to any practice.
  
-The KISS principle is about striving for simplicity. Modern programming languages, frameworks and APIs have powerful means to create sophisticated solutions for various kinds of problems. Sometimes developers might feel tempted to write "clever" solutions that use all these complex features. The KISS principle states that a solution is better when it uses less inheritance, less polymorphism, fewer classes, etc.+I would feel better if Obama would provide an exit strategy. Why can't he propose an honest review in 2020. Ask how people today are still uninsured. What medical services are being denied certain groups (elderly)? Has there been a rationing of services? What are the longer waits to getting urgent due care? What is the condition of end of life programs for your terminally perilous? How many people are dying because they can't get adequate care when they need it? You get the idea.
  
-A solution that follows the KISS principle might look boring or even "stupid" but simple and understandable. The KISS principle states that there is no value in a solution being "clever" but being easily understandable. +Fourth, improve your rep and be accepted as the competent. If all you're doing is marketing people on coming into your acupuncture clinic then that's all you're. a salesman (or woman). Properly write articles that get published on these article submission sites then happen to be automatically labeled an expert and can set yourself up considering the go-to an affiliate your marketplace. Articles make you look like an educator. Teachers are expected to exactly what they're sharing. Sales people just need understand how in order to your financial resources. So set yourself up as the teacher and you will be able to sell more and sell easier.
- +
-This does not mean that features like inheritance and polymorphism should not be used at all. Rather they should only be used when they are necessary or there is some substantial advantage. +
- +
-===== Rationale ===== +
- +
-A simpler solution is better than a complex one because simple solutions are easier to maintain. This includes increased readability, understandability, and changeability. Furthermore, writing simple code is less error-prone. +
- +
-The advantage of simplicity is even more significant when the person who maintains the software is not the one who once wrote it. The maintainer might also be less familiar with sophisticated programming language features. So simple and stupid programs are easier to maintain because the maintainer needs less time to understand them and is less likely to introduce further defects. +
- +
-One reason to create more complex code is to make it more flexible to accommodate further requirements. But one cannot know how to make it flexible or if that flexibility will be ever needed. +
- +
-"When you make your code more flexible or sophisticated than it needs to be, you over-engineer it. Some do this because they believe they know their system's future requirements. The reason that it's best to make a design more flexible or sophisticated today is to accommodate the needs of tomorrow. That sounds reasonable, if you happen to be a psychic." - Refactoring To Patterns - Joshua Kerievsky. +
- +
-Another reason to create more complex code is to make optimizations. An optimized code is a more complex code. Pareto principle applies also in code: a program spends most of the time in a small portion of the code, so it will be wise to concentrate the effort to optimize only that part of the code. Another best practice is to follow the  +
-"Three rules of optimization": (1. Don't, 2. Don't... Yet, 3. Profile before optimizing), which make sense: to optimize only the code with performance problems. (First author: Michael A. Jackson) +
- +
- +
-===== Strategies ===== +
- +
-This is a very general principle, so there is a large variety of possible strategies to adhere more to this principle largely depending on the given design problem: +
- +
-  * Avoid inheritance, polymorphism, dynamic binding and other complicated OOP concepts. Use delegation and simple if-constructs instead. +
-  * Avoid low-level optimization of algorithms, especially when involving Assembler, bit-operations, and pointers. Slower implementations will work just fine. +
-  * Use simple brute-force solutions instead of complicated algorithms. Slower algorithms will work in the first place. +
-  * Avoid numerous classes and methods as well as large code blocks (see [[More Is More Complex]]) +
-  * For slightly unrelated but rather small pieces of functionality use private methods instead of an additional class. +
-  * Avoid general solutions needing parameterization. A specific solution will suffice. +
-  * ... +
- +
- +
-===== Caveats ===== +
- +
-See section [[#contrary principles]]. +
- +
- +
-===== Origin ===== +
- +
-The principle was coined by the American engineer Kelly Johnson referring to the requirement that a military aircraft should be repairable with a limited set of tools under combat conditions ((Ben R. Rich: //[[http://www.nap.edu/html/biomems/cjohnson.pdf|Clarence Leonard (Kelly) Johnson 1910—1990: A Biographical Memoir]]//)). +
- +
-The principle of striving for simple solutions sometimes is also called "(rule of) simplicity"((Eric S. Raymond: //[[http://www.catb.org/~esr/writings/taoup/html/ch01s06.html#id2877917|The Art of Unix Programming]]//)) which was also prominently stated by Tony Hoare in his Turing Award lecture: "I conclude that there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult."((Tony Hoare: //[[http://awards.acm.org/images/awards/140/articles/4622167.pdf|The Emperor’s Old Clothes / The 1980 ACM Turing Award Lecture]]//)) +
- +
- +
-===== Evidence ===== +
-/* Comment out what is not applicable and explain the rest: */ +
-/*  * [[wiki:Proposed]]*/ +
-/*  * [[wiki:Questioned]]*/ +
- +
- +
-[[wiki:Accepted]]: This principle is widely known and accepted in practice. See for example Jargon File: //[[http://www.catb.org/jargon/html/K/KISS-Principle.html|KISS Principle]]// +
- +
-[[wiki:Examined]]: While the preference for simple solutions can be considered trivially intuitive, there has been some work relating simplicity or rather complexity and certain quality attributes. But as there is no universally applicable complexity metric and not even a commonly agreed upon clear definition of simplicity, research is bound to examine certain aspects of KISS independently.  +
- +
-The following hypotheses can be stated: +
-  - Simpler solutions are faster to implement. +
-  - Simpler solutions yield fewer implementation faults (which reduces testing effort). +
-  - Simpler solutions are easier to maintain, i.e. detecting and correcting defects is more effective and efficient. +
-  - Simpler solutions yield more reliable software, i.e. fewer defects show up after releasing the software. +
- +
-All these hypotheses can be examined with respect to different complexity metrics. +
- +
-Hypothesis 1 is true by definition. If the solution cannot be implemented quickly, it is not simple.  +
- +
-Though hypotheses 2 and 3 are not true by definition but they can be regarded intuitively clear. Nevertheless, there is some research. In ((Virginia R. Gibson and James A. Senn: //[[http://dl.acm.org/citation.cfm?id=62073|System Structure and Software Maintenance Performance]]//)) a system was improved in two steps resulting in three variants of the same system. Several metrics show that the improvements reduced complexity. 36 programmers with varying experience conducted three different maintenance tasks and their performance was measured. The results indicate that the improvements also improved maintainability. Several other studies support the correlation between complexity and maintainability((Chris F. Kemerer: //[[http://link.springer.com/article/10.1007%2FBF02249043?LI=true|Software complexity and software maintenance: A survey of empirical research]]//)). +
- +
-Furthermore, software cost estimation techniques are partly based on complexity judgments((Barry W. Boehm: //Software Engineering Economics//, IEEE)). So complexity---although this normally relates the complexity of the problem and not to the complexity of the solution---is a known cost factor which may be accounted to maintenance. +
- +
-Lastly, hypothesis 4 is likely to be false. Several studies relating complexity metrics and post-release reliability show that module size in lines of code predicts reliability at least as good as the McCabe metric (also called cyclomatic complexity) ((see Albert Endres, Dieter Rombach: //A Handbook of Software and Systems Engineering//, p. 168ff.)). Assuming cyclomatic complexity correctly depicts the complexity of a module, reliability should not the reason for applying KISS. +
- +
- +
-===== Relations to Other Principles ===== +
- +
-==== Generalizations ==== +
- +
-==== Specializations ==== +
- +
-  * [[More Is More Complex]] (MIMC): KISS states that one should strive for simplicity. MIMC makes this more concrete stating that more of anything (methods, classes, lines of code, ...) increases complexity. +
-  * [[You Ain't Gonna Need It]] (YAGNI) +
-  * [[Rule of Parsimony]] +
-  * [[Rule of Robustness]] +
- +
-==== Contrary Principles ==== +
- +
-Note that many principles are contrary to KISS. This means that it is worthwhile to consider KISS when considering one of those. Nevertheless this does not mean that this is true the other way around. When considering KISS, one wouldn't want to consider all principles that have complexity as a disadvantage. So here are those needing consideration: +
- +
-  * **[[Generalization Principle]] (GP)**: This is the directly converse principle. A generally applicable solution typically is not simple anymore. +
-  * **[[Murphy's Law]] (ML)**: The ultimate reason behind KISS is to increase maintainability and reduce the introduction of defects. But following KISS blindly by always using the simplest solution may also lead to //reduced// maintainability when Murphy's Law is not considered. +
-  * [[Model Principle]] (MP): There are often simpler ways to build a software system than to model and mirror the real-world behavior, which frequently means having more objects and more complicated structures. Nevertheless, it is advisable to do so anyway. +
- +
-==== Complementary Principles ==== +
- +
-==== Principle Collections ==== +
- +
-{{page>collections:OOD Principle Language#Box}} +
-{{page>collections:Unix Philosophy (Eric S. Raymond)#Box}} +
- +
- +
-===== Examples ===== +
- +
-==== Example 1: Fuzzy Simplicity ==== +
- +
-Simplicity is a blurry, partly subjective measure. Sometimes it is difficult to tell what is simpler. The following example shows that: +
- +
-<code java> +
-public String weekday1(int dayOfWeek) +
-{ +
-    switch (dayOfWeek) +
-    { +
-        case 1: return "Monday"; +
-        case 2: return "Tuesday"; +
-        case 3: return "Wednesday"; +
-        case 4: return "Thursday"; +
-        case 5: return "Friday"; +
-        case 6: return "Saturday"; +
-        case 7: return "Sunday"; +
-        default: throw new IllegalArgumentException("dayOfWeek must be in range 1..7"); +
-    } +
-} +
- +
-public String weekday2(int dayOfWeek) +
-{ +
-    if ((dayOfWeek < 1) || (dayOfWeek > 7)) +
-        throw new IllegalArgumentException("dayOfWeek must be in range 1..7"); +
- +
-    final String[] weekdays = { +
-        "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}; +
- +
-    return weekdays[dayOfWeek-1]; +
-} +
-</code> +
- +
-Both methods do exactly the same thing. They return a string representing the weekday. Just the implementation is different. Both versions may be seen as simpler than the other depending on the view taken. ''weekday2'' has less statements and less execution branches. Complexity metrics measuring these aspects (e.g. the [[glossary:cyclomatic complexity]]) will therefore prefer ''weekday2''. +
- +
-On the other hand ''weekdays1'' uses less language features (just switch, return, and exceptions whereas ''weekdays2'' needs if, arrays, arithmetic, return, and exceptions). Furthermore in ''weekdays1'' the relation between input and output can be seen directly and it's clear how it works by just seeing the method. But for understanding ''weekday2'' there are more details to think about. This is especially true for the range check at the beginning and the index computation in the ''return'' statement. Clearly this is not particularly difficult but these are aspects which are more difficult than in the other version of the method. +
- +
-So it's not objectively clear which of the two implementations KISS prefers without saying which complexity metric to apply. But this ambiguity is not a problem since principles are not meant to be unambiguous and objective. Eventually a human developer has to decide which solution to implement and the principles only give guidelines. +
-===== Description Status ===== +
-/* Choose one of the following and comment out the rest: */ +
-/*[[wiki:Stub]]*/ +
-[[wiki:Incomplete]] +
-/*[[wiki:Complete]]*/ +
- +
-===== Further Reading ===== +
- +
-  * [[wiki>KeepItSimple]] +
-  * [[wp>KISS principle]] +
-  * [[http://people.apache.org/~fhanik/kiss.html|Apache: KISS]] +
-  * [[http://www.catb.org/~esr/writings/taoup/html/ch01s06.html#id2877917|The Art of Unix Programming: Rule of Simplicity]] +
- +
-===== Discussion ===== +
- +
-Discuss this wiki article and the principle on the corresponding [[talk:principles:Keep It Simple Stupid|talk page]].+
principles/keep_it_simple_stupid.1764064423.txt.gz · Last modified: by christian