![3199296759_e5130dc6c1_z.jpg](https://steemitimages.com/DQmZ7zqajxuqWCpPtnUND4mXEnzhkMV3cg8p1ybmnxWNKjM/3199296759_e5130dc6c1_z.jpg) [source](https://www.flickr.com/photos/pagedooley/3199296759) I was searching for posts about computer programming on steemit and I've stumbled on this title: [C++ Program of (a) power b without using any builtin functions](https://steemit.com/programming/@learnandgrow/c-program-of-a-power-b-without-using-any-builtin-functions). I've decided to take a look at it. First thing you can notice reading it from the platform, is **the formatting** which makes it **unreadable**. So I've copied the text in an [online reformatter](http://format.krzaq.cc/). Then I had to fix the disappearing `*`, because `*`s pairs became *italics*. But this is just make-up which doesn't change the meaning of the code… The meaning? This code is total crap. **I am horrified**. I am a professional programmer who has also some experience reviewing students' code, and well, I've seen many mistakes and odd things, but something as pointless as this one… I don't remember anything like this. Moreover, **it doesn't what it says it does**, and this is the first clue any student should interpret as an invite to try harder. I'll be back on this later. Let's first face a possibile sad truth. # Self-steeming In this moment the post has 9 votes by: - tincho - imosco - macbaren - busy.org - learnandgrow (himself) - hanitasteemer - sauper-saiyanbot (a bot, I suppose) - sinbad989 - wolf-kinght These votes bring the post $8.62 (currently). Which is, I think, a very high value for 9 votes and for such a **low-quality post**. The `sauper-saiyanbot` also commented. Twice. With this text: > its really a great logic in this program And this other text: > amazing post The first comment has got 3 votes (for $0.25). These 3 votes are by - sauper-saiyanbot - hanitasteemer - learnandgrow The second comment has “only” 2 votes ($0.15), by `learnandgrow` and `sauper-saiyanbot`. Even if it is just a bot (very likely), the comments are surreal because the post is very ugly (wrong formatting), it looks bad, and the logic isn't great, it is sick — and also wrong, as you can see testing the program. Likely the author, [learnandgrow](https://steemit.com/@learnandgrow), and the bot [sauper-saiyanbot](https://steemit.com/@sauper-saiyanbot) are connected someway, hence no surprise the bot writes so far-from-reality comments. It comes to my mind an interview I've read today, [20 questions with @surfermarly (The Steemian Series)](https://steemit.com/life/@wadepaterson/20-questions-with-surfermarly-the-steemian-series). Question 10. > Some of your [surfermarly's] recent posts have analyzed questionable practices currently occurring on Steemit, which some would argue are toxic to the platform. I haven't read her posts so far (also, I am back just today and thought she was gone — instead I see she's back, good thing for steemit, I believe), so, just conjecturing right now: maybe they are talking about something more toxic, but since I've spotted this overvalued low-quality post with such nonsense comments, I think behind it there's one of these questionable practices. # Keep a decent quality If there are *questionable practices* which allows opportunist users with **low-quality effortless contents** to gain steem and attract even few ”big” votes, then common users producing good-enough-quality contents could surrender, because they see their efforts defeated by just “technique” and submerged by *crap*. They ask themselves, “how is it possible that this crap got so many and/or so big votes?”, and they go away. By the way, if an opportunist user uses the questionable practices **but** also produces high quality content, I think it's unfair but it comes no harm to steemit, because after all we have a good content. Besides, I would rather believe the user had so much positive feedback because of the quality of her work, and I wouldn't investigate if she has used or not *questionable practices*: it doesn't matter anymore because good contents should be rewarded anyway. Let's take a look at another combination: a user producing far-from-good **but honest** contents, and who doesn't use any trick. This can receive positive feedback, but it depends on the tastes or checks of the community, not on the *questionable practices*. What do I mean by “honest contents”? Well, let's talk about the post [C++ Program of (a) power b without using any builtin functions](https://steemit.com/programming/@learnandgrow/c-program-of-a-power-b-without-using-any-builtin-functions). It is clear to me that **there isn't any effort in that post**. He didn't care about the formatting on steemit, first thing first. Title aside, there isn't any initial text, a preamble explaining what he's going to write: **he just dumped the code**. You can like or dislike many different kind of posts, but you must realize that usually it is just because of your taste. The problem when posting computer code declaring what it does, is that it can be judged **objectively**. First of all: does it compile? Then, does it work, does it what the title (in this case) says? These are two basic **objective criteria** to judge the quality when all you have is just code. And about the code in that post… In the brightest case it looks like **unredacted homework**, and it also *works* like unredacted homework — that is, **it doesn't work**. Which makes you ask, why do you posted it? It's fine if a computer programming student post his code; he should, nonetheless, be confident that it works, hence being proud of it — *look what I did, and I'm just a novice!*; **otherwise** he should ask expert people on steemit to check if it is fine, or something like that, not selling it like a *way of computing a^b without using builtin functions*. Moreover, we shouldn't expect a void comment like “amazing post” or worse, a positive comment about the nonsense logic contained in the code. A programmer couldn't write such a positive comment without being pointed as **fake**. Anyway… I almost hope that the guys behind that post are here just to exploit steemit using *questionable practices*, totally uncaring about the content. Because otherwise it would mean that *really* somebody thinks that that post is amazing and the code has “great logic” inside! It would mean there's a danger for the human-programmed-computer driven world, if he wants to work in the information technology industry. And if he's the type who actually wrote the code thinking it does what he declared it does in the title, it also would show **the failure of the school system**. # Let's take a look at the code I want the reader to understand my astonishment, so be patient. First of all you have to keep in mind the aim: you want to compute a^b writing your own algorithm. We are all educated, I think, to know the very basic of such an expression when *b* is an integer: it means you have to multiply *a* b-times. For example, if *b* is 3, you compute `a*a*a`. And so on. And if *b* is negative? It can be proved that a^-b = 1/a^b, so you can compute a^b as before, then invert it, or you can multiply b-times the number 1/a (it isn't the same thing, but here we don't care). Because you have a^|b| as denominator, it must be not equal to 0 (otherwise we have a divide-by-zero error). What if *b* is 0? It can also be proved that a⁰ = 1. **Everybody older than fourteen should know this**. This is all you need to know to imagine the algorithm. It could look like this (pseudocode): ``` invert := false if b < 0 then invert := true b := -b end if result := 1 repeat b times result := result * a end repeat if invert is true then if result ≠ 0 then result := 1/result else error "1/0" end if end if ``` This is one way it can be done; I'm not saying this one is the best: it's just one among others. Anyway, **it's a simple algorithm** (luckly we're dealing only with integers; but the same algorithm works if *a* is a real number, too). Now take a first look at his code. Do you see the kind of simplicity you would expect from the pseudocode above? But, hey, maybe it works, despite the fact that there's some *code smell*, which usually means the code doesn't work; however it may seem to work for some input values. # I can't read the code, but can test the program! The code isn't only wastefully complicated — we could forgive it to a novice student, maybe. When you test it, looking at the pattern you realize that it isn't an “odd” or wrong implementation of a correct algorithm: it must be an “odd” (and maybe also wrong) implementation of a **wrong algorithm**. Before posting he should have checked the results with a calculator, then he wouldn't have posted the wrong code, would he? Let's try. num|ex|result|ok? ---|---|---|--- 0|0|1|Y 1|10|1|Y 2|10|1024|Y 2|-1|0.2|N 2|-2|0.02|N 2|-3|0.002|N -2|1|4|N 4|1|16|N -2|2|4|Y -2|3|-8|Y -2|-1|- 0.2|N -2|-2|- 0.02|N -2|-3|- 0.002|N 10|-1|0.10|Y 11|-1|0.11|N 12|-1|0.12|N 10|-2|0.10|N 12|-2|0.12|N 10|-3|0.010|N 100|-1|0.100|N 100|-2|0.100|N 100|-3|0.100|N 100|-4|0.0100|N -100|-4|- 0.000100|N 1000|1|1000000|N Ok, it's enough. I hope you get the obscenity of these results (it doesn't give the correct results even for a¹!) and from the pattern we can try to infer what kind of wrong algorithm he *tried* to implement — not succeeding… that is, we have a wrong implementation of a wrong algorithm! And, I can't stress it enough, **it can be easily seen**, and it should have been seen **before posting**. # The failure of the school system? I can imagine that when the program says that 4¹ = 16, it's because of a logic programming error; a *bug* which can be easily discovered by testing… (but I am arguing also that giving something good to the community wasn't his main concern). In fact, I refuse to believe that he doesn't know that 4¹ = 4. On the other hand, though, negative powers show a pattern which, regardless of the correct or wrong implementation, makes you think he doesn't know how something like a^-3 must be computed. We know that 10^-1 = 0.1, 10^-2 = 0.01, 10^-3 = 0.001, and so on. If you are very naive, and uneducated, or just too young to have studied these things, you can infer a wrong rule for negative powers: let `a` be a symbol (e.g. `10`), then `a`^-1 = 0.a, `a`^-2 = 0.0a, `a`^-3 = 0.00a, and so on. This inference should have been checked trying with 11^-1 (which isn't 0.11). Anyway, for 10^-2 his code doesn't give 0.010 but 0.10: a wrong implementation of the wrong algorithm? Or a correct implementation of an even worse and more obscure wrong algorithm? We can't say. But I bet that if there weren't anything to earn, he wouldn't have published such a code on his student blog… # Bad coding We can say that it's a (wrong) implementation of a wrong algorithm, and not a wrong implementation of the correct algorithm because we spotted a pattern when *b* is negative (and also because a¹ gives a²). Let's forget it for a minute and let's look at how the code does what it does (I cut the unimportant parts and use `<>` to label pieces of code). ``` if (num > 0 && ex > 0) { <>; } else if (num < 0 && ex > 0) { <>; } ``` See, `CODE_A` appears twice. Then the piece can be “reduced”: ``` if (ex > 0) { <>; } ``` and it continues like this: ``` else if (num > 0 && ex < 0) { <>; } else if (num < 0 && ex < 0) { <>; } else if (ex == 0) { <>; } else { // ... invalid exponent "expression"! ... } ``` When it reaches “Invalid exponent expression“ it's because *a* (`num` in his code) is 0 and the exponent is negative. A more correct error message is “division by zero” — but he doesn't any division, so the error is part of a rule learnt by heart, without understanding why it must be so. The `CODE_A` is the code responsible for the result a¹ = a². ``` <>: re = num * num; for (n = 2; n < ex; n++) { re = re * num; } ``` The error is clearly in the first line: `re` (the result) is initialized with a². Then, `n` starts from 2, and `2 < 1` (`ex` is 1) is false: the body of the loop isn't executed, but `re` is given as final result. A fix: ``` <>: re = 1; for (n = 0; n < ex; n++) { re = re * num; } ``` The `CODE_B` is a nightmare, and it isn't clear why it must different from `CODE_C`: they should have been the same, almost (except that when `num` is negative, he must write “-0.” instead of “0.”). Instead `CODE_B` behave differently according to the range `num` is in. This isn't “great logic”: this is beyond a faulty logic. Even if we accept the wrong algorithm as reasonable, entering this strange world where it makes sense, there aren't good arguments explaining why `CODE_B` and `CODE_C` should differ so much; in the worst case they should differ just for a sign printed before the “0.”. Moreover, what if `num` is between 1000 and 9999? Why this case, and all the others, aren't considered? Since `CODE_B` must be like `CODE_C`, I would group them; therefore ``` else if (num > 0 && ex < 0) { <>; } else if (num < 0 && ex < 0) { <>; } ``` becomes ``` else if (num != 0 && ex < 0) { <>; } ``` where `CODE_BC` is: ``` <>: if (num < 0) { cout << "-"; num = -num; } cout << "0."; ex = -ex; <>; cout << num; ``` The `BC_CORE` can be something like the code in `CODE_B`, with its if-elseif lines, or like the code in `CODE_C` (just a for loop). It doesn't matter because both are wrong, but for consistency one or the other should be used for both `num < 0` and `num > 0` cases, the only logical difference being handled as shown in `CODE_BC`. # Stop the conio.h thing When I reviewed students' code the `conio.h` was everywhere and I always explained why you shouldn't use it, nor add a pause at the end of your program: just run the program from a console — it seems hard to explain it to Microsoft Windows users, but if you study programming, you must know how to do it. Ask your teacher. Now, why those students (and few professors told them it was ok) feel the need to add a *pause* at the end of the program? They work in an IDE, maybe Microsoft Visual C++. They run the program from inside it, hence without a *console* for the *console output*, which is where text would go when you write `cout << "hello"`. When the program starts and try to write to console, the system (I don't care to be more precise here) opens a console to give room to the text the program is output. But that console exists as long as the program exists; this is why it suddenly disappear when the program ends, giving you no time to read whatever the program output. This is why students add a pause. Anything can work, even the reading of another input which then isn't used; like this: ``` string s; cin >> s; ``` This is ugly, too, but avoids the inclusion of a library which is for Microsoft Windows. Students should learn to write code which can work on any system where a standard C++ compiler exists, i.e. code written in standard C++ using the standard C++ libraries and nothing else. # Conclusion I hope I wasn't too harsh with the author and his post itself; but it isn't just the code which smells: the plauding comments are suspect, and the post is too careless (*dump the crap code here*), and nonetheless it has too much value already, **without having any merits**. It jeopardize the quality of steemit giving a bad content which teaches **wrong things**.