Category: Humor

User interfaces tend to map fairly naturally to trees as a data structure. In the modern world where we’ve forgotten how to make native UIs and do everything as web applications pretending to be native, the “tree” model is explicit via the DOM. But even in native UIs, we tend to group controls into containers and panels and tabs.

Now, there may be cases where we need to traverse the tree, and trees present us with a very natural way to traverse them- recursion. To search the tree, first search the subtree. Recursion can have its own problems, but the UI tree of a native application is rarely deep enough for those problems to be an issue.

Nick inherited some VB .Net code that iterates across all the controls in the screen. It does not use recursion, which isn’t a problem in and of itself. Every other choice in the code is the problem.

For Each x In Me.Controls
    Select Case (x.GetType.ToString)
        Case "System.Windows.Forms.Panel"
            For Each y In x.Controls
                Select Case (y.GetType.ToString)
                    Case "System.Windows.Forms.TabControl"
                        For Each z In y.Controls
                            Select Case (z.GetType.ToString)
                                Case "System.Windows.Forms.TabPage"
                                    For Each w In z.Controls
                                        If w.Tag = "Store Info" Then
                                            strName = CheckForExceptions(w.Name)
                                            iIndexStoreInfoValues = (arrStoreInfoValues.Length - 1)
                                            If w.GetType().ToString() = "System.Windows.Forms.CheckBox" Then
                                                arrStoreInfoValues(iIndexStoreInfoValues) = CType(w, CheckBox).CheckState
                                            Else
                                                arrStoreInfoValues(iIndexStoreInfoValues) = w.Text
                                            End If
                                            ReDim Preserve arrStoreInfoValues(iIndexStoreInfoValues + 1)
                                        End If
                                    Next
                            End Select
                        Next
                    Case "System.Windows.Forms.GroupBox"
                        For Each z In y.Controls
                            If z.Tag = "Store Info" Then
                                iIndexStoreInfoValues = (arrStoreInfoValues.Length - 1)
                                arrStoreInfoValues(iIndexStoreInfoValues) = z.Text
                                ReDim Preserve arrStoreInfoValues(iIndexStoreInfoValues + 1)
                            End If
                        Next
                    Case Else
                        If y.Tag = "Store Info" Then
                            iIndexStoreInfoValues = (arrStoreInfoValues.Length - 1)
                            strName = CheckForExceptions(y.Name)
                            arrStoreInfoValues(iIndexStoreInfoValues) = y.Text
                            ReDim Preserve arrStoreInfoValues(iIndexStoreInfoValues + 1)
                        End If
                End Select
            Next
        Case Else 
            For Each y In x.Controls
                If y.Tag = "Store Info" Then
                    iIndexStoreInfoValues = (arrStoreInfoValues.Length - 1)
                    arrStoreInfoValues(iIndexStoreInfoValues) = y.Text
                    ReDim Preserve arrStoreInfoValues(iIndexStoreInfoValues + 1)
                End If
            Next
     End Select
Next

At its deepest, this particular pile of code has 12 levels of indenting. Which I’ve cleaned up a bit here- as submitted, the code was using 8 spaces per tab stop, which made it entirely unreadable in a window of reasonable width. Not that it’d be readable at any width, mind you.

I’m not going to go line by line through this code. It’s not worth the psychic damage I’d inflict upon you. But I do want to call out a few highlights.

Note the repeated uses of ReDim Preserve arrStoreInfoValues.... This is an ugly VB hack for pretending to have arrays that can grow- ReDim creates an entirely new array, at the new size, and Preserve ensures that all the data in the original array gets copied over to the new array. It’s expensive and time consuming, and .NET has plenty of built-in data structures that make this unnecessary. Likely, this was inherited from some VB6 code that got ported over to .NET. It was a weirdly common convention in VB6, instead of using any sort of data structure that can grow.

In a few cases, we use a Select with only one branch to it- making it a fancy If statement but less readable. Now, there’s a good logic to this, I suppose, in that you may want more branches at some point, but I still hate reading it. Even worse, those switch statements are switching on the string representation of the type of the control. That particular code stench is always a “fun” thing to see, and it hints at an easy way to clean up this code: refactor those branches into methods, and use function overloading and the type system to replace the switches- if that were even necessary, as many of the branches do basically the same thing anyway.

But there’s no real point to cleaning up this code, because as Nick discovered: it didn’t actually work. The assumptions the code makes about how the controls are organized are false assumptions. It misses loads of controls in its traversal.

Nick replaced it with a 10 line recursive function that never needs to check the GetType of any of the controls.

X user (formerly known as Twitter, before Elon ruined it) @Jaythechou photoshops Paddington into movie scenes, and has been doing it every day for 1050 days, at the time of writing. Some are beautifully subtle, others are larger than life, but all are skilfully done and a lot of fun. We recommend you check out his work for yourself, but in the meantime, here is a Top 30, as voted by us. In no particular order.

During the Great Resignation, when millions of people left the workforce, the phrase “Nobody wants to work anymore” became a common sentiment among HR and business leaders who were having trouble with hiring.

However, as University of Calgary professor and researcher Paul Fairie pointed out referencing newspapers and other publications, these words have been thrown around every decade for at least the past century — going as far back as 1894.

So in an attempt to remind everyone that change starts from within, we went digging through the ‘Antiwork‘ subreddit and put together a list of posts about hypocritical bosses who should take a good look in the mirror before blaming the common folk for being lazy.

Mateus inherited some code where half the variables were named things like strAux1 and strAux2. It was a data driven application, and the data had some conventions that weren’t always ideal; for example, every city also had an associated abbreviation stored in its name field, e.g., “SAO PAULO (SP)” and “RIO DE JANEIRO (RJ)”.

The original developers wanted to be able to present the names of cities without the abbreviation, so they wrote this:

RTRIM(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(UPPER(ISNULL(C.CITY,'')),'(RS)',''),
'(SC)',''),'(PR)',''),'(SP)',''),'(MG)',''),'(RJ)',''),
'(DF)',''),'(ES)',''),'(MS)',''),'(MT)',''),'(BA)',''),
'(PI)',''),'(AL)',''),'(TO)',''),'(PE)',''),'(PA)',''),
'(CE)',''),'(RN)',''),'(MA)',''),'(AP)',''),'(RR)',''),
'(RN)',''),'(AM)',''),'(AC)',''),'(XX)',''),'(EX)',''),
'(SE)',''),'(PB)',''),'(GO)',''),'(RO)',''))

Whitespace added for readability(?).

The good news is that I don’t think Brazil is going to be adding any major cities deserving of their own abbreviation any time soon. But by effectively hard-coding the list of viable abbreviations instead of using more advanced string splitting (or *gasp* a regex), or y’know actually normalizing the data correctly, they’ve done a nice job making the code harder to maintain.

REPLACE REPLACE REPLACE REPLACE this code.

Correctly validating an email address, per the spec, is actually surprisingly hard. This is, in part, because there are a lot of features in the email address that nobody ever uses. Even so, you can easily get close enough with basic regex, and that’s what most people do.

Niels H‘s predecessor wanted to go a little farther. They wanted to ensure that the supplied domain name had a valid DNS entry. Overkill? Probably. But, fortunately for them the .NET framework supplies a handy System.Net.Dns.GetHostEntry method, which resolves a domain name. That at least makes the problem easy to solve.

It makes the problem easy to solve if you use it. But why use a built in method when you can do it yourself?

private bool IsValidDomain(string EmailAddress)
{
  List<byte> ByteList = new List<byte>();
  string DNS = GetDnsAddress();
  if (DNS == "") {
    throw new Exception("No DNS is found.");
  }
  if (EmailAddress.Contains("@")) {
    try {
      var HostName = EmailAddress.Split('@')[1];
      ByteList.AddRange(new byte[] { 88, 89, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 });
      var UDPC = new UdpClient(DNS, 53);
      foreach (string S in HostName.Split('.')) {
        ByteList.Add(Convert.ToByte(S.Length));
        char[] chars = S.ToCharArray();
        foreach (char c in chars)
          ByteList.Add(Convert.ToByte(Convert.ToInt32(c)));
      }

      ByteList.AddRange(new byte[] { 0, 0, Convert.ToByte("15"), 0, 1 });
      byte[] Req = new byte[ByteList.Count];
      for (int i = 0; i < ByteList.Count; i++)
        Req[i] = ByteList[i];
      UDPC.Send(Req, Req.Length);
      IPEndPoint ep = null;
      byte[] recv = UDPC.Receive(ref ep);
      UDPC.Close();
      var Resp = new int[recv.Length];
      for (int i = 0; i < Resp.Length; i++)
        Resp[i] = Convert.ToInt32(recv[i]);
      int status = Resp[3];
      if (status != 128) {
        return false;
      }
      int answers = Resp[7];
      if (answers == 0) {
        return false;
      }
    } catch {
      return false;
    }
  } else {
    return false;
  }
  return true;
}

Right off the bat, IsValidDomain is a badly named function, and badly designed. It takes a string containing an email address, and returns true or false if the email address contains a valid domain. I’d argue that a cleaner design would be to take the domain name part as the input, and let some other function worry about splitting an email address apart.

But that misses the forest for the trees, doesn’t it. This function has it all. It starts by hand-laying out the byte structure of a DNS request packet. Then iterating across a string to convert each character into a byte. And since we’re doing that in a List structure, we need to convert it into an array- but we can’t use the ToArray function, so we manually copy each byte into the array.

Then we send and receive a UDP packet for our DNS request. Note that we do create a variable to hold an IPEndPoint, the return value of GetHostEntry, which hints that maybe at some point, someone thought about using the build in function.

But once we’ve gotten our bytes back from the UDP packet, we copy the bytes into an array of 32-bit integers, simply upscaling each byte into 32-bits. Why? I have no idea. We still treat the array like bytes, moving to specific offsets to detect whether or not our request succeeded.

As a final note, I’m not the kind of person that gets hung up on “return from only one place in a function!” type rules, I think multiple returns are fine and can be cleaner to read in a lot of cases. But this particular one strikes me as annoyingly complex to follow, since we’re not just returning from multiple locations, but from multiple levels of blocks.

On the upshot, I’ve learned a little something about the structure of DNS packets today.

Melting Arctic ice in Siberia may release ancient “zombie” viruses, posing a potential global health crisis, leading scientists have recently warned. Geneticist Jean-Michel Claverie, professor emeritus of medicine and genomics at Aix-Marseille University, told The Guardian: “We now face a tangible threat, and we need to be prepared to deal with it. It is as simple as that.”

The World Wide Fund for Nature (WWF) has already reported that the Arctic’s average temperature has risen at a rate three times higher than the global average and is the region with the highest rate of average temperature change.

Melting Arctic ice in Siberia may release ancient “zombie” viruses, posing a potential global health crisis

Image credits: Jean-Michel Claverie/IGS/CNRS-AM

Experts have reportedly been collaborating with the University of the Arctic, an international educational and research cooperative, on organizing a surveillance network to assist with determining cases of diseases caused by the ancient micro-organisms, as early as possible, to avoid their spread spiraling out of control, the New York Post reported.

The monitoring network would supply quarantine facilities and medical services for those potentially infected by those zombie viruses to help minimize a potential outbreak, including preventing contagious patients from leaving the region, as per The Post.

The zombie viruses, scientifically recognized as Methuselah microbes, are reportedly capable of remaining viable for tens of thousands of years encased in the frozen soil, which covers nearly 20% of the Earth’s northern hemisphere.

Permafrost is any ground that remains completely frozen, 32°F (0°C) or colder, for at least two years straight

Image credits: Freepik

Professor Claverie said: “The crucial part about permafrost is that it is cold, dark, and lacks oxygen, which is perfect for preserving biological material.

“You could put a yogurt in permafrost, and it might still be edible 50,000 years later.”

According to NASA, permafrost is any ground that remains completely frozen, 32°F (0°C) or colder, for at least two years straight.

Experts have been collaborating with the University of the Arctic on organizing a surveillance network to help minimize a potential outbreak

Image credits: James Cheney

The geneticist also explained that the disappearance of Arctic sea ice, caused by global warming, posed a massive risk to human health, and added: “That is allowing increases in shipping, traffic, and industrial development in Siberia.

“Huge mining operations are being planned and are going to drive vast holes into the deep permafrost to extract oil and ores.

“Those operations will release vast amounts of pathogens that still thrive there. Miners will walk in and breathe the viruses. The effects could be calamitous.”

“We now face a tangible threat and we need to be prepared to deal with it. It is as simple as that,” geneticist Jean-Michel Claverie said

Image credits: NASEM Health and Medicine Division

Scientists reportedly believe that the deepest layers of permafrost could be preserving viruses that inhabited the Earth up to a million years ago, meaning long before humans’ most ancient ancestors, who are believed to have made their first appearance on the planet some 300,000 years ago.

As a result, if there were to be a zombie virus outbreak, we would have no natural immunity to defend ourselves against it.

Professor Claverie explained: “Our immune systems may have never been in contact with some of those microbes, and that is another worry.

“The scenario of an unknown virus once infecting a Neanderthal coming back at us, although unlikely, has become a real possibility.”

The zombie viruses, scientifically recognized as Methuselah microbes, are capable of remaining viable for tens of thousands of years encased in the frozen soil

Image credits: cottonbro studio

A lot of mystery surrounds the extinction of Neanderthals, with hypotheses including violence, transmission of diseases from modern humans to which Neanderthals had no immunity, competitive replacement, extinction by interbreeding with early modern human populations, natural catastrophes, climate change, and inbreeding depression.

Despite the chances of such prehistoric organisms breaking out of their frozen habitat in the most remote regions of Earth to start a new global pandemic remaining unlikely, virologists believe there’s at least some room for concern, as per The Post.

Virologist Marion Koopmans of the Erasmus Medical Center in Rotterdam revealed: “We don’t know what viruses are lying out there in the permafrost, but I think there is a real risk that there might be one capable of triggering a disease outbreak, say of an ancient form of polio.

“We have to assume that something like this could happen.”

“Here we go again,” a reader quipped

ADVERTISEMENT