Matt Ralston

Matt Ralston

M.Sc. Bioinfo + 5 years industry exp. - - - Looking for a position in biosciences. I'm gifted at the command line or computer terminal, but I perform best on my feet, standups, cleaning, guitar with samples in the centrifuge, more in the water bath, data being processed on the computer while I sleep, and other assays to plan. Currently writing a DNA sequence graph algorithm and manuscript (for bioRxiv). I play math rock on my guitar, I have some open-source software on GitHub, I pay my bills in the DE-NJ-PA tri-state area near Delco, and I'm launching a DE-based LLC for Univ. of Delaware and local NGS sequencing projects.

Ruining /r/programmerhumor memes

5 minute read

Published:

https://www.reddit.com/r/ProgrammerHumor/comments/8uqhfu/hell_yeah/

Hi everyone, today I’ll be ruthlessly destroying some /r/programmerhumor memes for those who are new to programming.

Gru Tries Recursion

https://www.reddit.com/r/ProgrammerHumor/comments/85a6n7/gru_tries_recursion/

Recursion is an elementary operation in logic, maths, and computer science where an operation is partially defined in terms of itself. While the most common example is the Fibonnaci function, the best example is perhaps addition of two integers:

Recursion in various languages

Basic Recursion: Addition
>def add(a, b):
>  if b = 0: # The 'exit condition' allows recursion to end, return value is *not* defined in terms of this function.
>    return a
>  else:
>    return add(a+1, b-1) # Here, the add function is called on incremented/decremented arguments.
Fibonacci: Iterative, Recursive, Tail-recursive
# P E R F O R M A N C E
# 2.7.10, GCC 4.2.1, Apple LLVM 8.0 on 2011 OSX
>import numpy
>import timeit
# Regular, non-recursive imperative/procedural implementation.
>def fibIter(n):
>  if n < 2:
>    return n
>  fibPrev = 1
>  fib = 1
>  for num in xrange(2, n):
>    fibPrev, fib = fib, fib + fibPrev
>  return fib
# Recursive, simple, and intuitive. But not very efficient for *machines* for larger n
>def fibRecur(n):
>  if n < 2:
>    return n
>  else:
>    return fibRec(n - 1) + fibRec(n - 2)
# Tail recursive, simple outer wrapper with defaults, efficient for machines.
>def fibTailRecur(n):
>  def fib(a, b, m):
>    if m < 1:
>      return a
>    else:
>      return fib(b, a + b, m - 1)
>  return fib(0, 1, n)
Fibonacci: Iterative, recursive, tail recursive
>require 'memory_profiler'
>def fibIter(n):
>  if n < 2:
>    return n
>  else:
>    a, b = 1, 1
>    (n-2).times {|x| a,b = b, a + b}
>  return n
>end

>def fibRecur(n)
>  if n < 2:
>    return n
>  else:
>    return fibRecur(n-1) + fibRecur(n-2)
>end

>def fibTailRecur(n)
>  def fib(a, b, m)
>    if m < 1
>      return 1
>    else
>      return fib(b, a+b, m-1)
>    end
>  end
>  return fib(0, 1, n)
>end

>

While the concept seems simple as presented here, a special type of recursion should be mentioned (as it's mentioned in nearly every other ignorant hipster treatment of recursion these days): tail recursion. Tail recursion is a special type of recursive treatment that results in a constant memory requirement as the recursion progresses, instead of the linear memory requirements afforded by poorly formed recursive functions. The differences can be seen in the 'Python' and 'Ruby' panels above.

Object-oriented Zucc

https://www.reddit.com/r/ProgrammerHumor/comments/8bh21u/not_oc_zuckerborgdrink/

Next, no discussion is complete in 2018 without mentioning OOP, by and far the dominant programming paradigm in industry. Too simplify, we'll assume basic knowledge of computer programs and describe a few classes of software. In the gif above is the actual source code of Zucc's internal programming. The .gif alludes to event-driven programming, where the 'state' of Mark's thirst is stored in a boolean attribute/instance-variable, accessed from zucc.isQuenched(). Mark responds to thirst with the following instance methods, some of which receive a hand instance: zucc.reach(right), zucc.grip(right), zucc.raise(right), zucc.sip(). The joke is obvious due to the high-level abstractions of the tasks, as well as appropriate method/instance names. Looking for more reading on objects, classes, instances and OOP? Here is an excellent review from Salman Khan.

FrontEnd vs. BackEnd

https://www.reddit.com/r/ProgrammerHumor/comments/7zfgwg/frontend_vs_backend/

I debated whether this meme deserved to make the cut and decided to include it for those who don’t have much experience making different kinds of applications. Not every developer will want to make different kinds of applications but I think this can still help everyone understand the perspective we give towards applications. There’s also a dual nature to discuss here and I’ll start with UI. User interfaces always need to be simplistic and intuitive to reach the most users. In my opinion, it is sad but true that utility doesn’t always win when it comes to the ‘value’ of an application and software developers that neglect their UIs are often punished.

That said, the image above the surface is calm, tranquil, and simple. The user is given a pretty, simplistic picture of the state of the creature, without any distraction or clutter. Of course this is the way things look to the user, but that does not at all mean that the code for the UI is in any way simple. In fact the above-the-surface depiction of simplicity and aesthetic is in stark contrast to the complexity of UI design. It takes a true love for artistic principles and design concepts to understand how the user thinks and what they value.

In contrast, the image shows beneath the ‘surface’ of the communication layer (HTTP/TCP) is an ugly creature, with different appendages, and a gruesome mechanical and technical feel. I’m sure that the abstract content of back-end source code might seem ‘ugly’ to front-end developers or even the user, but the functionality is anything but ugly. The aesthetic is in the structure of the app but also in convenient frameworks used by back server-side developers (e.g. Rails, Flask, Django, Express).

That’s it for this post! I’ll be doing this often I hope, ruining the punchline…

Extras

Does anyone else remember the Hawaii missile warning false alarm?

You May Also Enjoy

Ricing In 2024

less than 1 minute read

Published:

Customization is essential for maximizing visual appeal and ease of use of the computer system.

Linear Runtimes For Quasimapping And Alignment Free

1 minute read

Published:

I want to discuss linear runtimes and what that means in alignment-free methods for bioinformatics and sequence alignments and quasi alignments. First, it is the splitting of the sequences, as they are read, into, let’s say, ‘a’ De Bruijn graph. This graph consists of the k-mers, their neighborhoods, and of course the walks or paths through the graph that constitute optimal criteria and local maxima of course for traversal and contig/walk/path maximization. Typically, a search through the De Bruijn structure may be Breadth-First to find optimal depths for traversal of the path through the De Bruijn structure, optimizing for creating some sequence. This leads to read collapse along the sequence unidirectionally (bidirectionally in a unidimensional space) along the sequence space.