CodeSOD: The Map to Your Confession
Today, Reginald approaches us for a confession.
He writes:
I've no idea where I "copied" this code from five years ago. The purpose of this code was to filter out Maps and Collections Maybe the intention was to avoid a recursive implementation by an endless loop? I am shocked that I wrote such code.
Well, that doesn't bode well, Reginald. Let's take a look at this Java snippet:
/** * * @param input * @return */ protected Map rearrangeMap(Map input) { Map retMap = new HashMap(); if (input != null && !input.isEmpty()) { Iterator it = input.keySet().iterator(); while (true) { String key; Object obj; do { do { if (!it.hasNext()) { } key = (String) it.next(); } while (input.get(key) instanceof Map); obj = input.get(key); } while (obj instanceof Boolean && ((Boolean) obj).equals(Boolean.FALSE)); if (obj != null) { retMap.put(key, obj); return retMap; } } } else { return retMap; } }The first thing that leaps out is that this is a non-generic Map, which is always a code smell, but I suspect that's the least of our problems.
We start by verifying that the input Map exists and contains data. If the input is null or empty, we return it. In our main branch, we create an iterator across the keys, before ethering a while(true) loop. So far so bad
Then we enter a pair of nested do loops. Which definitely hints that we've gone off the edge of the map here. In the inner most loop, we do a check- if there isn't a next element in the iterator, we… do absolutely nothing. Whether there is or isn't an element, we advance to the next element, risking a NoSuchElementException. We do this while the key points to an instance of Map. As always, an instanceof check is a nauseating code stench.
Okay, so the inner loop skips across any keys that point to maps, and throws an exception when it gets to the end of the list.
The surrounding loop skips over every key that is a boolean value that is also false.
If we find anything which isn't a Map and isn't a false Boolean and isn't null, we put it in our retMap and return it.
This function finds the first key that points to a non-map, non-false value and creates a new map that contains only that key/value. Which it's a hard thing to understand why I'd want that, especially since some Map implementations make no guarantee about order. And even if I did want that, I definitely wouldn't want to do that this way. A single for loop could have solved this problem.
Reginald, I don't think there's any absolution for this. Instead, my advice would be to install a carbon monoxide detector in your office, because I have some serious concerns about whether or not your brain is getting enough oxygen.
Essex Air Ambulance Trust to host charity dance event with celebrity guests
Clarifications and Corrections
BBC Bailiffs and Homes Under the Hammer star, 46, sells uninhabited Thames island at a huge loss
Nearly 4,000 cyber-flashing crimes recorded in six months – Essex among highest
Ex-West Ham footballer Andy Carroll avoids driving ban after filming Essex protests
Essex man running 74 ultramarathons in 74 days will break Guinness World Record
Jeff Brazier's son reveals he attempted to end it all in newest TikTok
Essex Police officer dismissed for gross misconduct for inappropriate behaviour
Regular semi-detached home goes on sale for £320k - but it houses a remarkable secret inside
Police appeal as Essex man missing for 7 days-have you seen him?
I'm a Celeb fame Stacey Solomon shares new life update with fans
Fundraiser started for boy, 11, who died after GP told him he had 'just a virus'
Major disruption on all Greater Anglia trains to and from London Stansted Airport
Oasis support artist announced as headliner for Summer Series gig
Listed: Best 'cheap eats' Essex restaurants named among top in the country
Successful indie-pop band announced as next Essex Summer Series headliner
£110 million 'giga mansion' in Belgrave Square will become one of London's most expensive homes - with global billionaires targeted as most likely buyers
CodeSOD: Copied Homework
Part of the "fun" of JavaScript is dealing with code which comes from before sensible features existed. For example, if you wanted to clone an object in JavaScript, circa 2013, that was a wheel you needed to invent for yourself, as this StackOverflow thread highlights.
There are now better options, and you'd think that people would use them. However, the only thing more "fun" than dealing with code that hasn't caught up with the times is dealing with developers who haven't, and still insist on writing their own versions of standard methods.
const objectReplace = (oldObject, newObject) => { let keys = Object.keys(newObject) try { for (let key of keys) { oldObject[key] = newObject[key] } } catch (err) { console.log(err, oldObject) } return oldObject }It's worth noting that Object.entries returns an array containing both the keys and values, which would be a more sensible for this operation, but then again, if we're talking about using correct functions, Object.assign would replace this function.
There's no need to handle errors here, as nothing about this assignment should throw an exception.
The thing that really irks me about this though is that it pretends to be functional (in the programming idiom sense) by returning the newly modified value, but it's also just changing that value in place because it's a reference. So it has side effects, in a technical sense (changing the value of its input parameters) while pretending not to. Now, I probably shouldn't get too hung up on that, because that's also exactly how Object.assign behaves, but dammit, I'm going to be bothered by it anyway. If you're going to reinvent the wheel, either make one that's substantially worse, or fix the problems with the existing wheel.
In any case, the real WTF here is that this function is buried deep in a 15,000 line file, written by an offshore contract team, and there are at least 5 other versions of this function, all with slightly different names, but all basically doing the same thing, because everyone on the team is just copy/pasting until they get enough code to submit a pull request.
Our submitter wonders, "Is there a way to train an AI to not let people type this?"
No, there isn't. You can try rolling that boulder up a hill, but it'll always roll right back down. Always and forever, people are going to write bad code.