A brief introduction to Haskell

So, what I really wanted to do was to make a post about how functional programming concepts are useful after a discussion that came up in the shoutbox over my suggested use of a function as the second argument of string.replace in @Scuzz’s omdb plugin thread, but I realized that some of the more subtle examples are hard to show without rigorous syntax. So, I thought I would use this post to outline a bit of Haskell syntax which will touch on some functional concepts and lay the ground work for understanding examples in a later post arguing the utility of functional programming. DISCLAIMER: I’m not an expert in Haskell, nor have I built any real software with it, so forgive me if I remain in the conceptual domain

So, here we go!

First, if you want to play around with Haskell, it seems the go to is the Glasgow Haskell Compiler (GHC). Check out the Installation page at haskell.org

(P.S. on mac brew install ghci)

Maths

Arithmetic

As with all of our favorite interpreted languages, we can sit at the interpreter and do math all day:

> 2 + 4
6
> 2 * 4
8
> 2 ** 4      -- 2 ^ 4 (line comments in Haskell begin with --)
16.0

Great, so we know we have some predefined types and operations (technically speaking in the manner we’ve presented above, those literals are not primitives; they are actually boxed, but we’ll get there in time).

To exit the interpreter, use :quit

Variables

Like other languages, we can bind an expression to a name.

> let x = 10
> x
10

Variables MUST begin with a lowercase letter.

Unlike other languages, we cannot modify the value of x in a literal sense. We can rebind x, but this will create a new object rather than updating the old one. This leads to an important result:

> let x = 10
> x
10
> let x = x + 10
> x

In our favorite imperative language, we would expect to see the value of x updated to 20. However in Haskell it doesn’t evaluate.
Why? because we have defined x in terms of itself.
If we try to expand it, we get x + 10. Expand that, we get x + 10 + 10.

If that doesn’t make sense, think about it this way:
what we said is “where ever you see x replace it with x + 10”.
Now, if I asked you “what is x?” here, you can only answer “x + 10”
As you can see, this can never resolve to a value.

Functions

Of course, we can write our own math functions

> let addOne x = x + 1
> addOne 1
2

The syntax for defining a function is
let <function name> <variables> = <expression>
The syntax for calling is just
<function name> variables.

Function names MUST begin with a lowercase letter.

The interesting thing in Haskell (as well as other functional languages) is that functions are first-class citizens, meaning they can be treated like any other data. This allows us to do things like pass functions as arguments.

> let square x = x * x
> let applyTwice f x = f (f x)
> square 2
4
> applyTwice square 2      -- (2^2)^2
16

This is obviously a contrived example, but it shows that we can pass a function and then call that function.

Loading Haskell files

Ok, before we go any further, lets get off the cumbersome interpreter. A lot of future example code will be in files. When you see the ‘>’ you’ll know I’ve switched back to the interpreter, but just to make it clear, I’ll always show myself loading the file in question
e.g.

-- add.hs
add x y = x + y -- Function declaration syntax in a file (no need for let)

> :load add       -- load syntax (leave off the .hs)
[1 of 1] Compiling Main             ( add.hs, interpreted )
Ok, modules loaded: Main.
> add 2 4
6

Data

Custom Data Types

So at this point, we know how to

• do stuff with built in types
• declare variables
• declare and invoke functions
• load code from a file

Next, we would like to be able declare our own data types, much like being able to define our own classes.

For this section, we will be implementing our own Bool type which we’ll call Loob with values Yes and No

-- loob.hs
data Loob = Yes | No

data types MUST begin with a capital letter, like how functions must be lowercase.

What did this actually do, @Almost?
This defines a new data type, Loob
with 2 data constructors, Yes and No.

There isn’t a good equivalent to a data constructor in imperative languages, but the easiest way to think about it is kind of like an enum. We will see later how this notion isn’t quite right.

enum Loob {
    Yes,
    No
}

Let’s take a look at our new type.

> :load loob
> let x = Yes
> x
Yes
> :type x      -- Gets type information from a variable
x :: Loob      -- Format: <name> :: <type>

The let x = Yes statement instructs the interpreter to use the Yes data constructor to instantiate a new Loob and assign it to the variable x.
Meaning the data of x is now Yes and the type of x is now Loob.

In imperative space this is kind of like
Loob x = Loob.Yes

Going back to loob.hs, let’s define our own and function which we’ll call dna.

-- loob.hs
data Loob = Yes | No
  
dna Yes Yes = Yes
dna No _ = No
dna _ No = No

> load loob.hs
> dna Yes Yes
Yes
> dna Yes No
No
> dna No Yes
No
> dna No No
No

This example shows off a couple of important points in Haskell.
Functions can take arbitrary parameters
the _ in the function definition means “any argument” in can be any type, any value, we don’t care. We know that No and Anything is always No, so we don’t even need to look at the second argument. This does have the side effect that dna No 1234 is defined as No which may or may not be desirable. Since we don’t give _ a name, we can’t use it in the body of our function. It literally means “I don’t need to know, nor even care what this data is”

Functions can have multiple definitions over the same argument data type
It might be hard to see what I mean due to the usage of _ but we could have written out all the cases explicitly:

dna Yes Yes = Yes
dna No Yes = No
dna Yes No = No
dna No No = No

In an imperative world, this should be alarming. We just overloaded dna 4 times and each one takes 2 Loob arguments! If I were to calls:

> let x = No
> let y = Yes
> dna x y

How should it know which of the 4 functions to use?

This is where our enum notion falls apart.

Haskell uses the data constructor for the variables to perform pattern matching to find the first definition that matches the input.

therefore our example above explicitly matches the 2nd definition for dna, so that one will be used.

While defining our own pseudo primitives is nice and all, can we define actually useful types, like say Pair?
Sure. While we didn’t take advantage of it before, our data constructors can act as a tag for other data:

-- pair.hs
data Pair t = Pair t t -- Declare data type Pair of t (where t is an arbitrary type). You might write this as Pair<T> in C++ or Java
  
left (Pair x y) = x
right (Pair x y) = y

Don’t be confused here. I’ve named both the data type and data constructor “Pair”.
in our functions, left and right, the argument is weird. That looks like how we construct a Pair doesn’t it?

That’s exactly what it is. Haskell’s pattern matching basically says “Could I use this syntax to construct the object that you gave me? If yes then we have a match, if not we don’t have a match”

To try it out:

> :load pair
> let p = Pair 1 2
> left p
1
> right p
2

Lists

Haskell’s list syntax is similar to that of python:

> [1,2,3,4]
[1,2,3,4]

Haskell, however, has syntax to create a list over a range:

> [1..10]
[1,2,3,4,5,6,7,8,9,10]

One interesting fact about Haskell lists, due to the fact that Haskell performs lazy evaluation, an infinite list is completely legal and will not cause a crash or hang unless you attempt to evaluate the whole list:

> let x = [1..]
> -- no crash :)

Accessing an element of the list can be done with the !! operator.

> let x = [1..]   -- infinite list
> x !! 9
10                -- 0 indexed

Remember, the lazy evaluation means that only as much as is actually used is evaluated which means that indexing an infinite list is completely legal.

Given a list, you can prepend it with the : operator

> let x = [2,3,4]
> 1:x
[1,2,3,4]

This is handy since we can use this list building syntax as a pattern in a function (as we discussed in the last section)

> let head (x:xs) = x  -- x is the first element, xs is the rest of the list
> head [1,2,3]
1
> let tail(x:xs) = xs
> tail [1,2,3]
[2,3]

What we’re saying here is that the argument of head and tail is “Something (x) appended to a list (xs)”

An aside, Haskell represents strings as lists of characters

> head "Almost"
'A'

:type

Simple types
I brought up :type discreetly in the custom data types section. You can learn a lot about how Haskell works by examining the output of :type.

> :type 1
1 :: Num a => a

Read: 1 has type (Num a) which reduces to a

What this actually tells us is that:

1. 1 is not a primitive, but rather of type a
2. a is restricted to those types in the Typeclass Num

That second point is similar to the concept of requiring that a generic type extends some known type in Java:
public class Foo<? extends Collection>

Other simple examples:

> :t True       -- :t works in place of :type
True :: Bool
> :t "Almost"
"Almost" :: [Char]
> :load loob    -- from a previous example
> :t Yes
Yes :: Loob

Function types

we see some new syntax when we look at functions

> let square x = x * x
> :t square
square :: Num a => a -> a

Let’s ignore the point that a must be in the Num Type class and focus on the a -> a
You can read this as a goes to a
Meaning, square takes a variable of type a and returns a type a.
As a concrete example, square can take an integer and return an integer.

What’s the type of a function that takes 2 variables?

> let add x y = x + y
> :t add
add :: Num a => a -> a -> a

Hmm. a -> a -> a huh?
“a goes to a goes to a?” I don’t get it.
well, let’s apply some grouping to help us out.
Let’s read it as a -> (a -> a) For now, trust me that this is better than (a -> a) -> a. I’ll explain why this is the case later.
In this view, we read “a goes to (a goes to a).”
Still a little fuzzy? Well, remember that
a -> a means that it’s a function that takes an a and returns an a.
Therefore
a -> (a -> a) should mean that it’s a function that takes an a and returns a function that takes an a and returns an a.

But that doesn’t make sense. Add takes 2 numbers and returns one number. It doesn’t take 1 number and return a function.
Or does it?

> :t (add 1)
(add 1) :: Num a => a -> a

Why did that work? Add takes two arguments god damn it! That should have given us an error!

In imperative languages we’re used to the fact that a function that has two arguments requires that you supply two arguments when you call it (or at least that you specify default in the case of optional values such as int myFunc(int myInt, bool myBool = false)).

Haskell has no such requirement.

When we evaluate add 1 2 anywhere we see x we replace it with 1 and anywhere we see y we replace it with 2.
Therefore add 1 2 is equivalent to 1 + 2
But what forces us to replace both x and y? Why can’t we replace just x?
Why shouldn’t we call add 1 and get back 1 + y?
> Because you can’t evaluate 1 + y, @Almost…
Exactly. We can’t evaluate it until we are supplied with a y. So instead of trying to evaluate it, we just give that expression back and say “give me a y and I’ll evaluate this.”

Gee, that sounds like a function, doesn’t it?

Rather than just looking at the type, let’s try giving that new function a name

> let addOne = add 1
> addOne 2
3

Woah. So it really does give us back a function.

This magic process of partially evaluating functions is called Currying (Named after one Haskell Curry. The guy was a bit of a narcissist: he named both a programming language and a mathematical concept after himself.)

Currying has a very useful property in that it naturally supports code reuse and encapsulation

A simple contrived example:

> let pow x y = y ** x        --Yes, this is a bit backwards from how we usually think of pow
> let square = pow 2
> let cube = pow 3

As you can see, it gives us a really simple way to build software without reinventing the wheel or writing many many lines of code. On a philosophical level, this makes it easy for us to show that cube is just a specific case of the more general pow. We don’t get such an obvious connection if we write cube as cube x = x * x *x.

Now. An astute reader might be thinking: isn’t it kind of weird that we have 2 ways to evaluation functions: fully and partially?

Actually this is not the case. There is only one way to evaluate a function: By supplying one argument.

add 1 2 is not passing 2 arguments to add, rather it is actually evaluating as (add 1) 2 - apply 1 to add and the apply 2 to the resulting function.

What implication does this have on how Haskell treats functions?
In Haskell a function has exactly one input and exactly one output.
Either or both of the input and output can be functions, but there cannot be more than one input or output.

Now, before we wrap up our section on function types and currying, let’s talk about why we chose a -> (a -> a) instead of (a -> a) -> a.
How do we read the second one?
“add takes a function and returns an a”.

This should be valid then:

> add add

clearly that doesn’t make sense, therefore (with all the handwaving I have in me :P) this is not a valid way to read that type signature.

In the case where the argument truly is a function, Haskell will indicate that to us

>let applyToOne f = f 1
> :t applyToOne
applyToOne :: Num a => (a -> t) -> t

Don’t be scared by t. This just tells us that the return type of the function f as well as applyToOne isn’t necessarily the same type as the type o the input to f

e.g.

> let equalsOne x = x == 1
> :t equalsOne 
equalsOne:: (Eq a, Num a) => a -> bool

Conclusion

tl;dr There is no tl;dr. Go read it.

Whew. Rushed is probably a better word than brief. I hope that was reasonably easy to follow, and if not, please ask questions. I want to both help you understand and improve my own technical communication.

If some sections make absolutely no sense even with some of my clarification, don’t worry too much. This stuff is very different from the usual “state-machine” style of programming that most of us are familiar with. But just because it’s different, don’t count it out. A lot of the concepts introduced in functional programming are making their way back into mainstream programming languages (e.g. Lambda Expressions, Nullable Types, LINQ).

If you’re interested in learning more about Haskell, Learn You a Haskell for Great Good is the standard Textbook. It’s free online legally, so no need to go searching for it.

Hope you enjoyed that. Help me improve this!
<3 Almost

There was some confusion in the shoutbox about formatting with tabs and spaces, namely: “Why does it look fine on my computer, but look like shit on github?”

The answer is in the difference between tabs and spaces.

Part 1 - Tabs vs Spaces

In a monospaced font, a space character is exactly 1 character in width.
In a monospaced font, a tab character’s width is defined by whatever is rendering it.

It is common for a tab character to have a width of 4 characters, but 3, 6, and 8 show up on occasion.

For example, this markdown and the gist below it are using the exact same text:

    Hello - 4 spaces
	Hello - 1 tab

https://gist.github.com/Kern--/52be2592e8517d6b7625 (Sorry -- become – outside of quotes)

You’ll notice that the top line looks the same in both places, but the line below it is aligned on the forum, but not aligned in the gist. That’s because the forum uses 4 character wide tabs but the gist uses 8 character wide tabs.

Part 2 - Why are tabs stupid?

You may be thinking “why would you want tabs to render differently? Why isn’t there a standard width?”

The answer is because people have preference. Lets say you think everything should be indented 6 spaces and your reaction is “6 spaces?!? Are you fucking out of your mind? 3 spaces is the perfect indentation!”

If I go out and use 6 spaces, while you’re using 3, our code would look terrible and inconsistent and no one is happy. If we both agreed to use tab characters, I can set my editor to display tabs as 6 characters, and you can set yours as 3 characters. Then, we each see indentation how we want and even if we both look at a computer that’s using 8 characters and think “This is the ugliest code ever”, at least the indentation is consistent.

So actually tabs aren’t stupid. They allow the look you want without causing inconsistency with other people’s look.

Part 3 - Text Editors FTL

At some point the idea that tabs are stupid came back. “Why does this look different here? Why aren’t we all seeing the code the same way? Minimizing differences between our view of the code is the only way we can be productive”

So let’s pretend we’ve agreed that tabs are dumb. We’ve all decided we can live with 4 spaces of indentation, but I’m a lazy computer scientist and that tab button was really convenient. :/ But wait! We’re not using tabs any more! So the tab button won’t be used, right? Why don’t we make the tab button insert 4 spaces?

Most text editors let you override tab to insert a specified number of spaces. That way, you can still use the tab button, but it will look the same for everyone.

In my opinion, this is a huge mistake. Especially if you’re using a number spaces corresponding to a common rendering of tab, it makes it easy to accidentally mix them.

E.G. on my computer, tab inserts 4 spaces. Then I switch computers and keep working, but I forgot to set the editor on this computer to replace tab characters. Well, if this editor renders tabs as 4 characters, it looks fine on my computer, but once I switch back to my old computer (which used 8 characters), I’ve got the same inconsistency issues I was trying to get rid of!

The “replace tab with x space characters” is a useful option for the lazy programmer, but it also pushes the issue into the background, making it easy to accidentally mix tabs back in.

Part 4 - Conclusions

There were a few things I wanted you to get out of this post:

1. The difference between tabs and spaces
2. Why people want to use tabs
3. Why people don’t want to use tabs
4. How text editors made the whole issue that much more confusing

What does this all mean for you?
Make sure you know whether the existing codebase is using tabs or spaces AND know whether your editor is replacing tab characters with spaces

Keep that in mind, and formatting issues should be easy to resolve. (P.S. the nodebb source uses tab characters)

I hope you guys got something out of this. <3 Almost

Hey guys!

I was at BestBuy yesterday and went over to play with their moto360 display. If you haven’t seen non-marketing images of the devices, then here’s your chance!

First, the overall look

And Compared to my daily watch (sorry for quality)

The look works pretty well, if you ask me. My wrists aren’t huge, but it still looks fairly natural on my wrist. It’s a little thick, but not so much so that it stand out if you weren’t looking specifically at the thickness.

I didn’t find the black bar too distracting, but I agree that it would be nice to have a fully circular display. At the same time, I’d much rather have the tiny bezels and a black bar than a thicker bezel (see this and this)

As we already knew, it’s a pretty watch.

---

From the review by The Verge

The screen looks great at a glance, but not under close scrutiny: its 320 x 290 resolution is low enough that you’ll see jagged edges on letters and can easily make out individual pixels, and the beveled edges of the Gorilla Glass give off a sort of shimmering moiré pattern.

In my opinion, this statement is more misleading than it is useful. The bevel causes a small amount of rainbow moire patterns that the edges (see picture below; look at right next to the button) and yes, if you look close enough, the screen is not perfect.

But my problem with that statement is that the moire patterns are about as noticeable as the rainbow stuff in the image below, and “looking close enough” involves holding the watch about 3" from your face. The screen is good. Trying to point out it’s shortcomings is just looking for an excuse to say something bad about the watch.

Eh. Rotation.

---

Lastly, the charging station

I don’t know if I missed this or glossed over it in my previous looks, but the charging moto360 is really pretty. I would probably use this at my bedside in the place of an actual alarm clock (my phone is all I have currently).

---

After holding a demo device, I have to say that my opinion of the moto360 is largely unchanged. It’s a beautiful device with few (if any) aesthetic downsides.

Seeing as it was just a demo unit, I can’t speak to the internals (others with the actual device have said some very unfavorable things). I would like to see some more long term battery life and performance reviews under more normal conditions (i.e. after getting past the new device constant fiddling stage), although I still don’t have high hopes that it will live up to the expectations of a consumer product.

I’m still thinking about getting it, but not because I think it’s a finished product. I think it’s the best bet for an early chance at testing the utility of smart watches. I’ll keep you all posted.

Hey guys!

Today I got Cardboard in the mail!
How I feel right now.

For those of you unfamiliar with cardboard, it’s google’s ultra-cheap VR demo. Some cardboard, a few lenses, velcro and tape if you’re feeling really fancy, and the smartphone you already have is all you need to experience VR at home. There are instructions for how to make your own at home, but the original was a small package containing everything you need with a simple 6-step assembly. Google gave these kits out at I/O 14, and through a friend with close ties to google I managed to get ahold of one so that today I can give you guys and unboxing and a review. Let’s get started!

Outer Packaging

The outer packaging is simple. It’s small, but bigger than I was expecting - about as thick as a DVD case, but an inch or so bigger in both height and width. On the front there’s a nice picture of the asembled device.

The back is equally simple. A few warnings and a pull tab to get started.

Pulling off the tab and peeling the cardboard back leads us inside, but not quite to the actual device. It comes with a “3D Token” but I can’t find anything about what this is for. The only thing the internet can find is this reddit thread where redditor /u/thetickz seems equally baffled. Whatever.

The device

Detach where it says and flip it over and we finally see the actually cardboard device.

Once we remove the outer package from underneath, we see how much smaller the cardboard is that actually makes up the device. It’s got instructions printed on it, and it’s pretty simple to follow, although I did have trouble figuring out exactly how to bend it in step 2. Maybe I’m just an idiot

Fully Assembled

TADA!

Lacking a 3rd arm to take pictures while I assembled, I opted to skip that process. Here it is all put together.

And from the front.

The “button”

As you can probably guess, once your phone is inside the device you can’t exactly interact with it. This is where google has done their second coolest work (besides making a nearly free VR system, of course).

On the inside of the device is a magnet. On the outside is a washer in a oval groove. Pulling down on the washer causes the magnetic field to be all weird (technical terms, bear with me) which tries to pull the washer back up, directly over the magnet. When you pull and release quickly, this causes a disturbance in the magnetic field which your phone’s compass can detect, thus allowing the washer to act like a button.

Check out this gfycat:
https://gfycat.com/JampackedCarelessGermanwirehairedpointer

DISCLAIMER: I think that explanation is correct, but I’m assuming a lot of things. I might be very wrong.

Review

Sorry guys. The pictures end here.

So, What’s Cardboard actually like? When I was first mentioning it in the shoutbox, I got this horrible feeling that I might have to explain that “actually, it’s not that cool” and “eh. It’s ok, I guess” but once I actually tried it out, I was blown away.

The cardboard app is pretty cool. Load it up, it teaches you how to put together your cardboard as well as how to get to the main menu of the cardboard app.

At the main menu, you’re given some options: tour Versailles, look at some African masks, google earth, google streetview, your own photospheres, an animated short, and youtube (not in that order). You navigate this menu by turning in a circle. The option in front of you get’s bigger to let you know you’re selecting it, and a flick of the washer launches you in.

The first 5 things I mentioned are similar in terms of what they do. You stand in the center of a sphere which you can turn 360 degrees and look up and down. It feels as though you’re standing exactly in that spot and you can look at any point around you. The only think you can’t do is move closer/further from the objects around you. If you’re like me and have never experience VR, it’s REALLY cool.

The 6th item, the animated short, is similar to the previous group, but feels slightly different. You watch this couple minute long animation where you’re standing just a few yards from the action (or so it feels). The story moves from your right to your left, and as you follow the action you realize that there are more things in the world than you thought. Of course you can still look in 360 degrees but you can’t really follow the story if you’re not looking at it. I couldn’t help but imaging watching a full movie like this. It is such a surreal feeling to actually be able to control the viewpoint when watching a story, one that I hope we’ll be able to do with all movies in the future.

Lastly is the YouTube app. This one is completely different from the others. When you load it, you’re looking at a screen which gives the feeling of sitting in a movie theater. Some video plays, in my case it was a music video that I didn’t recognize (I’m not sure if it would change for different people/viewings. Might be a random popular video or something). Looking down shows a speech icon, and clicking the washer allows you to voice search youtube. If you do this, the first video it finds immediately plays. Looking around behind you reveals a wall of video tiles, much like that room in The Stanley Parable - you know the one - but with much fewer options. These seem to be related videos, popular videos, etc, although they aren’t labeled, so it’s kind of hard to tell. Once again, a flick of the washer starts them. Overall, it’s a pretty cool way to watch videos.

Beyond the official Cardboard app, Google released a google cardboard api. There are a handful of apps on the play store, but the only real notable one is a 3d spherical asteroids-like game. This is really too bad, because the technology is quite cool. The back of the device even has a slot for your camera, so making AR games/apps is definitely doable.

My overall feeling of Cardboard is that it’s a fantastic cheap demo, but I wish it were more. The demos are really really cool, especially since I’ve never seen VR before (unless you count my 3DS :P ), but you can only look at 5 rooms in Versailles for so long. It’s fun, but I think the novelty will wear out quickly, and since it’s temporary, it’s unlikely to pick up enough dev support to make it great. I guess I shouldn’t be too bummed out, it’s really cheap, even if you make it yourself, and it is really cool. Asking for a piece of cardboard to be much more than that is asking quite a lot. I don’t want to make it sound like I’m disappointed in Cardboard. I’m actually super excited about it! It’s just a little painful to think that it likely won’t progress much further than it’s already at.

Well, thanks for reading this far! I hope I gave you some insight. On one last note, I actually received 3 of these things in the mail. I’m keeping mine, @Scuzz claimed one, but I’m not sure what I’ll do with the third. Maybe I’ll have a giveaway ;). Stay tuned.

srsly wtf is this?

It’s the 27th! That means 13 shiny new episodes of House of Cards.

I’ll be your host tonight on this riveting liveblog full of ACTION (but no spoilers). Enjoy!

[7:15 PM] Here we go
[7:16 PM] That music. That shot. Is this what we think it is? Or are they going to pull a fast one on us?
[7:19 PM] Huh.
[7:19 PM] Hah.
[7:22 PM] Woah. Well…
[7:26 PM] WTF? Why is he there?
[7:27 PM] LOL. I’m going to do that to my kids.
[7:28 PM] I had a roommate like that. No joke.
[7:29 PM] U think I O U A Apology?
[7:33 PM] Wherever you are, I will find you and I will kill you. YES I KNOW THAT’S NOT THE ACTUAL QUOTE.
[7:40 PM] Speaking of everyone, I hear they love Raymond.
[7:43 PM] :) -> :(
[7:46 PM] No one has a clue at the Burrow. Fucking Weasleys.
[7:51 PM] Shit’s scary yo. Also fuck that guy.
[7:53 PM] No product placement will ever be as blatant as “Is that a PS Vita?”
[8:00 PM] Shit’s hairy yo. Also fuck that guy.
[8:03 PM] No don’t! Keep refusing!
[8:04 PM] BRB Gotta get snacks. Stay tuned folks!
[8:26 PM] Back on track. Resuming.
[8:28 PM] That condescension
[8:37 PM] Shit it takes a cold person to want that.
[8:42 PM] Well produced C-Span could be really cool.
[8:44 PM] lol. You done fucked up.
[8:46 PM] oh. You done fucked up.
[8:48 PM] That music is familiar. Reminds me of a particular comment.
[8:53 PM] He certainly is a son of a bitch.
[8:59 PM] That’s a jump. Also fuck those snide comments.
[9:01 PM] I like this scene. Also holy fuck did it take me a long time to realize that they live in the Whitehouse now.
[9:01 PM] A collect call from - Ayla Sayyad - an inmate at the Maryland Correctional Facility (Ya’ll fuckers didn’t even listen to that series, did you?)
[9:05 PM] I can’t even keep up with all that’s going on!
[9:06 PM] Have you ever noticed that all two times have been transactional? And yet I’m still not sure that’s so bad
[9:08 PM] SMASH IT!
[9:10 PM] What do you have in mind? “A vague monologue”
[9:11 PM] The music this season is on point.
[9:14 PM] Maaaaaaaaan. Fuck you and your incompetence.
[9:19 PM] Whoops. Froze my beer.
[9:20 PM] Political correspondence: We speculate that they’re considering assume that this statistic explains the american public’s assumption of speculation.
[9:26 PM] Damn. That would fucking sweet to see.
[9:27 PM] I’m going to start calling him Rob (man was that an obscure reference)
[9:28 PM] P.S. guys, it’s fucking hard to do this and to pay attention to what’s actually happening. There is no doubt in my mind that the Jenny story was entirely made up.
[9:33 PM] Well, it was symbolic.
[9:37 PM] “Impressive. But also fuck you”
[9:42 PM] I’m a young people.
[9:43 PM] AMERICANS KNOW THAT CITY
[9:43 PM] Sarcastic af
[9:44 PM] No, you’re just accidentally wasting my time. Forgive me, I don’t know these quotes well enough.
[9:50 PM] Did I mention that the music is on point?
[9:52 PM] Shit. I think that might have actually been them. Like IRL.
[9:56 PM] Wait, but wasn’t that the goal? Or is everyone being played?
[9:58 PM] Ugh. I liked you better at the end of last season.
[10:00 PM] That was such a good exchange. Other than the fact that one person is a total douchebag.
[10:01 PM] I want a liquor bottle made of gold.
[10:03 PM] There’s got to be some political gain happening here. I just can’t tell what it is.
[10:06 PM] Is that [redacted]? (sorry guys. that one had a spoiler :x)
[10:07 PM] Woah. Did that just happen?
[10:13 PM] I can’t even talk about code that coherently at that point in my night.
[10:21 PM] Had to rewatch that section like 4 times. I think I followed.
[10:22 PM] I feel like everything is symbolic. It probably is.
[10:23 PM] GET ME A CONTINENT ON THE PHONE
[10:24 PM] The further into this I get, the harder it is to not spoil things. Who would’ve thought?
[10:27 PM] Damn.
[10:28 PM] Lol. They’re not very good.
[10:50 PM] We’re back after a brief musical interlude
[10:57 PM] Shit. I already forgot what the significance of this interaction is. I think I’m losing steam.
[11:03 PM] Oh yeah. I remember now.
[11:04 PM] The funny part is that I wouldn’t even be a little surprised if those systems actually looked like that. We all remember [I can’t give it away :(].
[11:09 PM] How worthless can you be?
[11:12 PM] I thought I was special D:
[11:15 PM] I held my tongue for as long as I could. I don’t like that hair.
[11:19 PM] Finally.
[11:20 PM] SHUT UP HALLWAY BROS I’M TRYING TO WATCH HOUSE OF CARDS
[11:22 PM] Wow. That thing that happened totally caused other things to happen.
[11:24 PM] When’s that thing that I was looking forward too going to happen?
[11:26 PM] There’s something incredibly creepy about fishing for answers that you already know.
[11:29 PM] Not sure if play or srs. This show mirite?
[11:32 PM] WTF is he wearing? Am I seeing things?
[11:33 PM] Show yourself, Peter.
[11:35 PM] Actually, I don’t think I’ll buy this.
[11:36 PM] Holy fuck. How symbolize 101.
[11:37 PM] Ok, Ok. I think that’s enough for tonight. My attention is slipping and the alcohol is setting in. Tune in next time for another spoiler free liveblog. G’night BB.

lmao wft does any of this even mean?

Good background while working.

https://www.youtube.com/watch?v=92xjD7j1B5Q

oic = one-handed sideways baby
lol = guy on a rollercoaster

Feels like a song for @President_Choob

https://www.youtube.com/watch?v=MrPZDhI1Ink

Maybe they expected you to do two passes?

def satisfiesF(L):
    x = []
    for item in L:
        if f(item):
            x.append(item)

    for item in x:
        L.remove(item)

    return len(L)

Seems like a bad question to me.

If we’re going with the second interpretation (where you return a new list) I think this would work:

def satisfiesF(L):
    return [x for x in L if f(x)]

Man, this is really awkward way to phrase a question about filtering.

Nice job, though. Good to see you doing shit again :P

EDIT: Is it safe to modify a list while iterating over it in python? A quick google search suggests no.

https://www.youtube.com/watch?v=84fbU39V0Ko

this video is not far off from what their live presence is like.

Thank you for introducing Mr Polska to me, @Schamper XD

https://www.youtube.com/watch?v=olSZH-OAJWE

@President_Choob
https://www.youtube.com/watch?v=I-xAWE-4tkM