DEV Community

Cover image for Share a code snippet in any programming language and describe what's going on
Ben Halpern
Ben Halpern

Posted on

Share a code snippet in any programming language and describe what's going on

#discuss #watercooler

Top comments (66)

Collapse
 
ben profile image
Ben Halpern •

I'll go first with Ruby

class String
  def like_a_cow
   "Moo #{self} mooooo"
  end
end

"Hello".like_a_cow
=> "Moo Hello mooooo"
Enter fullscreen mode Exit fullscreen mode

Classes in Ruby can be easily modified. The above code adds the like_a_cow method to String... So now the whole program can make a string "moo", like above.

Collapse
 
maxart2501 profile image
Massimo Artizzu •

In JavaScript it's:

String.prototype.like_a_cow = function() {
  return `Moo ${this} mooooo`;
};
"Hello".like_a_cow()
> "Moo Hello mooooo"
Enter fullscreen mode Exit fullscreen mode

I wonder how many languages allow this?

Collapse
 
ryencode profile image
Ryan Brown • • Edited

C# allows this,


    public static class StringExtension
    {
        public static string LikeACow(this string self)
        {
            return $"Moo {self} mooooo";
        }
    }
Enter fullscreen mode Exit fullscreen mode

you can now use this as

Console.WriteLine("Hello".LikeACow());
Enter fullscreen mode Exit fullscreen mode

I use extensions a lot on sealed library classes to add Quality Of Life things. One example is creating cleaner methods for adding parameters to SQLClient ClientCommand objects as one liners instead of multi-command monstrosities. (ok, they aren't that big, but do look unclean)

Thread Thread
 
lionelrowe profile image
lionel-rowe •

I think it's different (safer) in C# though, right? Like you need to add using <namespace> for the new methods to be accessible. So it's not true monkey patching, which is generally dangerous and best avoided.

Thread Thread
 
ryencode profile image
Ryan Brown •

Indeed you would need to use the containing namespace. And are likely safer as it would be pretty hard to modify the behaviour of code outside of your intended changes. (I think you would have to try very hard to have any affect outside of your explicit calls to the extension methods)

I won't claim to know much about TRUE monkey patching, but wikipedia's Extension Methods and Monkey Patching articles do reference each other in suggestive ways. ;)

Collapse
 
arjunsahlot profile image
Arjun •

Python:

class str(str):
    def like_a_cow(self):
        return f"Moo {self} mooooo"

str("Hello").like_a_cow()
> "Moo Hello mooooo"
Enter fullscreen mode Exit fullscreen mode

I should add that this is not good practice. str is a built in function and you should not override it.

Collapse
 
kenbellows profile image
Ken Bellows •

I'll do you one better: if you define a dynamic getter using Object.defineProperty, you can make it look exactly like the Ruby example:

Object.defineProperty(String.prototype, 'likeACow', {
    get() {
        return `Moo ${this} mooooo`
    }
})

'Hello'.likeACow
> 'Moo Hello mooooo'
Enter fullscreen mode Exit fullscreen mode
Collapse
 
jmfayard profile image
Jean-Michel ๐Ÿ•ต๐Ÿปโ€โ™‚๏ธ Fayard • • Edited 
fun String.likeACow() = "Moo $this mooo"
Enter fullscreen mode Exit fullscreen mode

Same thing in Kotlin, super handy.

EDIT: A big advantage with for example the JavaScript version monkey-patching String.prototype, is that the String class is not modified everywhere in your codebase.

It works like a normal function, you import the new function only if and where you need it. See kotlinlang.org/docs/extensions.htm...

Collapse
 
silverhairs profile image
Boris Kayi • • Edited

In Dart it's

extension on String{
 String get like_a_cow => 'Moo $this mooooo';
}

"Hello".like_a_cow;
=> "Moo Hello mooooo"
Enter fullscreen mode Exit fullscreen mode
Collapse
 
leopfeiffer profile image
Leo Pfeiffer •

Similar in Scala:

extension(str: String) {
  def like_a_cow = s"Moo ${str} mooooo"
}

scala> "Hello".like_a_cow
val res0: String = Moo Hello mooooo
Enter fullscreen mode Exit fullscreen mode
Collapse
 
maowtm profile image
maowtm •

In Rust you can add functions to other types with traits. This actually adds the like_a_cow function for all types that are printable, including strings. You have to use the trait though.

pub trait LikeACow {
    fn like_a_cow(&self) -> String;
}

impl<T: std::fmt::Display> LikeACow for T {
    fn like_a_cow(&self) -> String {
        format!("Moo {} mooooo", &self)
    }
}

fn main() {
    // need to `use LikeACow;` if used in other modules, but not here.
    let s = "hello";
    println!("{}", s.like_a_cow());
}
Enter fullscreen mode Exit fullscreen mode
Collapse
 
sanzstez profile image
Alexandr Stets •

It is bad practice to do such things. Better use

module Extensions
  refine String do
    def like_a_cow
    end
  end
end
Enter fullscreen mode Exit fullscreen mode

and add in you class

use Extensions
Enter fullscreen mode Exit fullscreen mode
Collapse
 
darkwiiplayer profile image
๐’ŽWii ๐Ÿณ๏ธโ€โšง๏ธ •

Nice example, but I think it could be refined somewhat

using (Module.new do
  refine String do
    def like_a_duck
      "#{self} quack quack"
    end
  end
end)

puts "Hello".like_a_duck
Enter fullscreen mode Exit fullscreen mode
Collapse
 
auroratide profile image
Timothy Foster •

Some regex I wrote in 2018:

/^(?:\*|\d\.)\s(.*)\r?\n([ \t]+(?:\*|\d\.)\s(?:.|\r?\n[ \t]+(?:\*|\d\.))*)/
Enter fullscreen mode Exit fullscreen mode

I've stared at it for 5 minutes and still can't tell you what's happening ๐Ÿ™ƒ

Collapse
 
chrisgreening profile image
Chris Greening •

Dear programmer: When I wrote this code, only god and I knew how it worked. Now only god knows it! Therefore, if you are trying to optimize this routine and it fails (most surely), please increase this counter as a warning for the next person: total hours wasted here= 254

Collapse
 
tracygjg profile image
Tracy Gilmore •

If you throw the expression into something like Debuggex it can map out the routes through the expression, as follows.

RegExp diagram

However, whilst this shows what is happening it does not indicate why.

Collapse
 
auroratide profile image
Timothy Foster •

Now that I'm staring at this chart, I'm recalling that at some point I was trying to parse markdown. Pretty sure this is looking for nested lists:

* Hello!
  1. A nested ordered list
Enter fullscreen mode Exit fullscreen mode

Though, it is interesting to me that the initial * or \d\. is not captured; one would think it'd be important to distinguish between an unordered and ordered list...

Thread Thread
 
tracygjg profile image
Tracy Gilmore •

I studied the screenshot I attached to my comment and came to the same conclusion but it looks to me the expression might be more complicated than it needs to be - without fully understanding the context of course.

Collapse
 
bbrtj profile image
bbrtj •

It searches for indented sublists, like:

1. abc
  * def
  * ghi
Enter fullscreen mode Exit fullscreen mode

You're welcome.

Collapse
 
jamesthomson profile image
James Thomson •

Anyone that can read this and know exactly what's going on is clearly not human

Collapse
 
jeremyf profile image
Jeremy Friesen •

Lots of (?:\*|\d\.) repeated: non-capture region of either * or (any numeral followed by any character).

Collapse
 
3kiruthick profile image
3Kiruthick •

Which purpose u wrote this regex

Collapse
 
lionelrowe profile image
lionel-rowe •

PHP

function lets_do_some_math($n) {
    return ($n / 2) / ($n / 2);
}

$a = lets_do_some_math(10);
$b = lets_do_some_math(11);

printf('%d %d %s', $a, $b, $a === $b ? 'yes' : 'no');
Enter fullscreen mode Exit fullscreen mode

Prints 1 1 no.

In PHP, the division operator / returns an integer if the two operands are both integers and divide exactly, and a float in all other cases. (10 / 2) thus gives int(5), while (11 / 2) gives float(5.5). Then, in the next division step, 5 / 5 gives int(1), while 5.5 / 5.5 gives float(1).

PHP's language design is truly astounding.

Collapse
 
rajarshi profile image
Rajarshi Bandopadhyay • • Edited

All right, let's see if you guys have a clue about this:

docker commit `docker ps -a |\
    head -n2 |\
    tail -n1 |\
    cut -d" " -f1` $1:$2
Enter fullscreen mode Exit fullscreen mode

This is a single line of shellscript code written over three lines for readability. Notice that it employs backticks inside the code.

A lot is happening here, obviously. FIrst of all, the $1 and $2 will be replaced by the first and second command line argument respectively. So if you are invoking this script with the command line arguments repo and tag, this will translate to:

docker commit `docker ps -a |\
    head -n2 |\
    tail -n1 |\
    cut -d" " -f1` repo:tag
Enter fullscreen mode Exit fullscreen mode

Next, note the backticks inside the command. The portion between the backticks - will first be evaluated. The result of this evaluation will then replace the entire thing inside the backticks.

Now, what does the portion inside the backtick do? Well, it has four parts:

Part 1 is docker ps -a, which yields a list of Docker images and their details:

CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS                     PORTS     NAMES
20d03205fe06   ubuntu:20.04   "bash"                   3 seconds ago   Exited (0) 2 seconds ago             bold_feynman
dcf460b2c4ff   07cd54330caf   "/bin/sh -c 'tar xzfโ€ฆ"   4 minutes ago   Up 4 minutes                         blissful_liskov
Enter fullscreen mode Exit fullscreen mode

This output is then piped into part 2. Piping is a special construct in Shellscript, which takes the string output of one command and puts it into the string input of the next command. So if command-1 prints 2+2+2 into the output, and command-2 evaluates mathematical expressions from keyboard and prints the output, then command-1 | command-2 will basically make the 2+2+2 from the first command become the input of the second, and we will only see the final output - 6.

The output of the first command is being piped into the second command, which is head -n2. The head command snipes out the first n lines from a file (or text input), and prints it. When fed the lines of details of different classes at the input, the head command will print the first n lines and then ignore the rest. We specify n with the -n2 flag, and its value is set to 2.

So the head command will print the first two lines from the table:

CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS                     PORTS     NAMES
20d03205fe06   ubuntu:20.04   "bash"                   3 seconds ago   Exited (0) 2 seconds ago             bold_feynman
Enter fullscreen mode Exit fullscreen mode

Notice that this includes the heading row and the details of the latest image - in this case, one which was created just three seconds before this command was run (I admit to having created it just to demonstrate this snippet).

The next command in the pipe is tail, and this command will ignore all but the last n lines from the input, and print those last n lines. In this case, we invoke it with tail -n1, thereby setting n to 1. The last one line will be printed.

20d03205fe06   ubuntu:20.04   "bash"                   3 seconds ago   Exited (0) 2 seconds ago             bold_feynman
Enter fullscreen mode Exit fullscreen mode

Or at least, tail will try to print it. But its own printed output has been further piped into the cut command. This command does something quite whacky: it takes two arguments, known as the delimiter and the selected columns. The delimiter has to be a char and the selected columns is a comma-separated sequence of numbers. In case a single number is provided, that single number is interpreted as a single-length sequence of numbers.

What cut does is that it splits each line of its input into parts, separated by the delimiter. It then takes the specific values which correspond to the selected columns, and then prints only those values which have been selected.

For instance, in this case, it will split the input string (which is a single line) by the " " space character, and then take out the first member of the resulting array of substrings. Of course, this effectively means that it will only pick the first word of the line. And in this case, that word is the container ID of the most recently run container:

20d03205fe06
Enter fullscreen mode Exit fullscreen mode

This ID is the final output of the entire portion inside the backticks, and given the way Shellscript works, the entire portion inside backticks will simply be replaced by this one container ID number:

docker commit 20d03205fe06 repo:tag
Enter fullscreen mode Exit fullscreen mode

Which is the final form of the command, and it is executed. So the command does this:

It commits the most recently run container as an image with the name and tag provided as command line arguments to the script

Collapse
 
pandademic profile image
Pandademic •

Wow.... That's actually quite useful

Collapse
 
rajarshi profile image
Rajarshi Bandopadhyay •

Thank you. I use this one a lot, though I typically write it out in just one line.

Collapse
 
sm0ke profile image
Sm0ke • • Edited

Nothing in c++

int main() { return 0; }
Enter fullscreen mode Exit fullscreen mode
Collapse
 
dhravya profile image
Dhravya •

Here's a Rust moment, I tweeted it today lol

Collapse
 
jroes profile image
Jon Roes •

Is your text editor or some plugin showing the return types of the functions in the chain? That's pretty cool. What's the plugin/editor?

Collapse
 
dhravya profile image
Dhravya •

I'm using VScode with rust-analyzer extension

Collapse
 
tunaxor profile image
Angel Daniel Munoz Gonzalez • • Edited

This is an F# script that posts a Post like object to the json placeholder API and deserializes the json response to a Post.

you can copy into a file and run it like this:

  • dotnet fsi ./filename.fsx 
#r "nuget: FsHttp" // specify the http library

// open the required namespaces
open FsHttp
open FsHttp.DslCE
open System.Text.Json

// define the shape of the data
// these are known as Records in F#
type Post =
    { userId: int
      id: int
      title: string
      body: string }

// In F# records can't have null values for most types
// so we use an anonymous record (`{| |}` instead of `{}`)
// because we don't have an id value yet
let payload =
    JsonSerializer.Serialize(
        {| userId = 1
           title = "Sample"
           body = "Content" |}
    )

let response =
    // declare the request
    http {
        POST "https://jsonplaceholder.typicode.com/posts"
        body
        json payload
    }
    // send the request, it can also be done asynchronously
    |> Request.send
    // get the stream back (rather than downloading the response in bytes/string
    |> Response.toStream
    // deserialize it using .NET base class library classes like JsonSerializer
    |> JsonSerializer.Deserialize<Post>

// you can now check the response in the console
printfn "%A" response
Enter fullscreen mode Exit fullscreen mode
Collapse
 
darkwiiplayer profile image
๐’ŽWii ๐Ÿณ๏ธโ€โšง๏ธ • 
private["_min", "_max", "_mid", "_target", "_kit"];
_target = random(_sum);
_min = 0; _max = count _array -1;

while { _min != _max-1 } do {
   _mid = floor (_min + (_max - _min) / 2);
   if ( (_array select _mid select 0) <= _target )
      then { _min = _mid }
      else { _max = _mid };
};
Enter fullscreen mode Exit fullscreen mode

Does a binary search through an array and finds the first element with a value greater than a random target at index 0.

This is a part of a script that chooses a random set of items to put in a supply box where each item set can have a weight assigned to it based on how valuable the items are (higher weight means more common)

Collapse
 
pandademic profile image
Pandademic •

what language is that?

Collapse
 
darkwiiplayer profile image
๐’ŽWii ๐Ÿณ๏ธโ€โšง๏ธ •

SQF :D

Collapse
 
yassineldeeb profile image
Yassin Eldeeb ๐Ÿฆ€ •

I'm gonna bet on Brainf*ck, so here's mine.

>+++++[>+++++++<-]>.<<++[>+++++[>+++++++<-]<-]>>.+++++.<++[>-----<-]>-.<++
[>++++<-]>+.<++[>++++<-]>+.[>+>+>+<<<-]>>>[<<<+>>>-]<<<<<++[>+++[>---<-]<-
]>>+.+.<+++++++[>----------<-]>+.<++++[>+++++++<-]>.>.-------.-----.<<++[>
>+++++<<-]>>.+.----------------.<<++[>-------<-]>.>++++.<<++[>++++++++<-]>
.<++++++++++[>>>-----------<<<-]>>>+++.<-----.+++++.-------.<<++[>>+++++++
+<<-]>>+.<<+++[>----------<-]>.<++[>>--------<<-]>>-.------.<<++[>++++++++
<-]>+++.---....>++.<----.--.<++[>>+++++++++<<-]>>+.<<++[>+++++++++<-]>+.<+
+[>>-------<<-]>>-.<--.>>.<<<+++[>>++++<<-]>>.<<+++[>>----<<-]>>.++++++++.
+++++.<<++[>---------<-]>-.+.>>.<<<++[>>+++++++<<-]>>-.>.>>>[-]>>[-]<+[<<[
-],[>>>>>>>>>>>>>+>+<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>[<<<<<<<<<<<<<<+>>>>>>>>
>>>>>>-]<<+>[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-
[-[-[-[-[-[-[-[-[-[-[-[<->[-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]<[
<<<<<<<<<<<<[-]>>>>>>>>>>>>[-]]<<<<<<<<<<<<[<+++++[>---------<-]>++[>]>>[>
+++++[>+++++++++<-]>--..-.<+++++++[>++++++++++<-]>.<+++++++++++[>-----<-]>
++.<<<<<<.>>>>>>[-]<]<<<[-[>]>>[>++++++[>+++[>++++++<-]<-]>>++++++.-------
------.----.+++.<++++++[>----------<-]>.++++++++.----.<++++[>+++++++++++++
++++<-]>.<++++[>-----------------<-]>.+++++.--------.<++[>+++++++++<-]>.[-
]<<<<<<<.>>>>>]<<<[-[>]>>[>+++++[>+++++++++<-]>..---.<+++++++[>++++++++++<
-]>.<+++++++++++[>-----<-]>++.<<<<<<.>>>>>>[-]<]<<<[-[>]>>[>+++[>++++[>+++
+++++++<-]<-]>>-.-----.---------.<++[>++++++<-]>-.<+++[>-----<-]>.<++++++[
>----------<-]>-.<+++[>+++<-]>.-----.<++++[>+++++++++++++++++<-]>.<++++[>-
----------------<-]>.+++++.--------.<++[>+++++++++<-]>.[-]<<<<<<<.>>>>>]<<
<[<+++[>-----<-]>+[>]>>[>+++++[>+++++++++<-]>..<+++++++[>++++++++++<-]>---
.<+++++[>----------<-]>---.<<<<<<.>>>>>>[-]<]<<<[--[>]>>[>+++++[>+++++++++
<-]>--..<+++++++[>++++++++++<-]>-.<+++++[>----------<-]>---.[-]<<<<<<.>>>>
>]<<<[<+++[>----------<-]>+[>]>>[>+++[>++++[>++++++++++<-]<-]>>-.<+++[>---
--<-]>.+.+++.-------.<++++++[>----------<-]>-.++.<+++++++[>++++++++++<-]>.
<+++++++[>----------<-]>-.<++++++++[>++++++++++<-]>++.[-]<<<<<<<.>>>>>]<<<
[--[>]>>[>+++++[>+++++[>+++++<-]<-]>>.[-]<<<<<<<.>>>>>]<<<[<++++++++++[>--
--------------<-]>--[>]>>[<<<<[-]]]]]]]]]]]>>]<++[>+++++[>++++++++++<-]<-]
>>+.<+++[>++++++<-]>+.<+++[>-----<-]>.+++++++++++.<+++++++[>----------<-]>
------.++++++++.-------.<+++[>++++++<-]>.<++++++[>+++++++++++<-]>.<+++++++
+++
Enter fullscreen mode Exit fullscreen mode

Please don't ask what it does, cause I've no idea, it just looks cool..I guess.

Collapse
 
ashleyjsheridan profile image
Ashley Sheridan • • Edited 
10 PRINT "You been hacked!"
20 GOTO 10
Enter fullscreen mode Exit fullscreen mode

BASIC hacking

Collapse
 
ben profile image
Ben Halpern •

whoa

Collapse
 
crowdozer profile image
crowdozer • 
// javascript 

{
  const x = 1
  {
    const x = 2 // no error
    {
      console.log(x) // 2
      const x = 3 
      console.log(x) // 3
    }
  }
}

console.log(x) // undefined
Enter fullscreen mode Exit fullscreen mode

In javascript, const denotes a read-only variable. If you try to reassign it, you'll get a "SyntaxError: Identifier has already been declared"

However, each braced segment is treated as a new scope. This is most obvious with functions and control structures like if (true) { ... }, but it's not immediately obvious to people that you can arbitrarily create new scopes anywhere. Switch statements are a good place to use them.

Collapse
 
moopet profile image
Ben Sinclair •

Const doesn't denote read-only, it only means you can't reassign it in the same scope. You can mutate it all you want (provided it's a type that's mutable in the first place)

const x = [1, 2, 3];

x.push(4);
delete x[0];

// [ <empty slot>, 2, 3, 4 ]
Enter fullscreen mode Exit fullscreen mode
Collapse
 
crowdozer profile image
crowdozer • • Edited

I worded it a bit slopy, a "read-only reference to a value" according to MDN, but it's all semantics as long as we understand how it works =]

Collapse
 
pothieug profile image
Gilles Pothieu •

Wow, thanks for the hint !

Collapse
 
gajananpp profile image
Gajanan Patil •

Custom characters on 16x2 LCD Display using LiquidCrystal library of Arduino

byte heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};

lcd.createChar(0, heart);
lcd.setCursor(0, 1);
lcd.write(byte(0));
Enter fullscreen mode Exit fullscreen mode

displays on lcd as
LCD Character

used to spend whole day creating different custom chars and animations

Collapse
 
warwait profile image
Parker Waiters •

JavaScript

parseInt("fuck", 16);
๐Ÿ‘‰ 15
parseInt("fart", 16);
๐Ÿ‘‰ 250
parseInt("shit", 16);
๐Ÿ‘‰ NaN
Enter fullscreen mode Exit fullscreen mode

JavaScript will parse a string until it gets to an character it can't parse and then return the value. In this example, by parsing hexadecimal, we get f in the first example, fa in the second, but nothing in the third because s isn't a valid hex character.

Collapse
 
w3ndo profile image
Patrick Wendo •

Classic FizzBuzz, but in a language a friend and I worked on called Swahili-lang. Uses Swahili semantics with a JS-lik syntax,

You can find out more about it here

shughuli fizzBuzz(nambari){
  kwa i = 1 mpaka (nambari+1){
    kama (i % 15 == 0){
      andika (Jina(i) + ": Fizz Buzz")
    } au (i % 5 == 0){
      andika (Jina(i) + ": Buzz")
    } au (i % 3 == 0){
      andika (Jina(i) + ": Fizz ")
    } sivyo {
      andika (i)
    }
  }
}
Enter fullscreen mode Exit fullscreen mode
Collapse
 
saptakbhoumik profile image
SaptakBhoumik • 
def fib(n:int) -> int :
    if n <= 0:
        return 1
    return fib(n-1) + fib(n-2)

def main():
    count:int = 0
    res:int = 0

    while count < 40:
        res = fib(count)
        count++
Enter fullscreen mode Exit fullscreen mode

Recursive fib in peregrine which is a python like language I have been working on:). Check it out :- github.com/peregrine-lang/Peregrine

Collapse
 
pandademic profile image
Pandademic •

nice ! look's great!

Collapse
 
saptakbhoumik profile image
SaptakBhoumik •

Thanks:)

View full discussion (68 comments)

Some comments may only be visible to logged-in visitors. Sign in to view all comments.

Read next

esponges profile image

AI Automated Engineers - Are We Doomed?

Fernando Gonzรกlez Tostado -

nikl profile image

What we built for our Notification Service?

Nik L. -

rytheturtle profile image

QuickBytes: Stop Using Lombok's @NonNull

RyTheTurtle -

kecbm profile image

Como Participar da Bolha Dev no Twitter: Um Guia para Desenvolvedores

Klecianny Melo -