Let’s make Twitter a better place by ridding it of trolls

One app to block them all


We’ve built a proof of concept for a Twitter service that automatically blocks trolls for you.

We call it Troll, Abort! Give it a try.

We’ve also made a less than two minutes long video where we explain some more. Watch it on Vimeo.

Now we’re looking for organisations, companies and individuals to collaborate with to make this happen. We need both time and money. Get in touch with us on [email protected]. Help us spread the word by sharing this article, trollabort.com and @trollabort.


Online harassment and hate is not a new problem. I received a hand-written letter with threats back in 2002 when I was moderating a Swedish tech forum. These days, with the rise of social media and more people accessing the Internet, things have gotten a lot worse. This is not an easy problem to solve, but we want to do something and have decided to focus on Twitter.

Have you read “Why Twitter’s Dying (And What You Can Learn From It)” by Umair Haque? Umair hits the spot regarding Twitter’s harassment problem and it’s definitely worth 9 minutes of your time.

Let’s look at what Twitter offers to help us.

We’ve been able to block accounts for a long time. Muting first showed up in some third party clients (Tweetbot was first?) and is now a part of Twitter itself.

Since last summer, we’re also able to export a list of accounts we’ve blocked and share it with someone else. These can then be imported, resulting in those accounts being blocked for the one who imports them as well. This operation requires that you use a computer though. That makes it hard for a lot of Twitter’s users.

So we do have some tools at our hands to block and mute. But it’s not easy nor convenient.

About a month ago Twitter announced the new “Trust and Safety Council”. It sounds like a good initiative so let’s hope for the best here.

To sum things up: Twitter could be an amazing place but apparently they’re in a tight spot. So we’re trying to help them.

What we want to do

We want to build a service that Twitter users can subscribe to, which automatically blocks bad accounts. It will be 100% free forever (or as long as Twitter allows us…).

We’ve built a proof of concept to prove that the idea works with Twitter’s APIs and you can try it today:


Of course you can still manually block account but by subscribing to this service we’ll make sure that you don’t have to meet the worst trolls.

These are the trolls we’re blocking in this test phase (how any of these accounts can be around at all is a mystery to us).

How the service works

As easy as 1…2… and not even a 3.

1. Sign in with your Twitter account

2. Flip the switch block and subscribe to automatic updates

That’s it. Now enjoy Twitter with less trolls.

If you miss the trolls then just come back to us at any time and flip the switch again to unsubcribe.

We need your help to make it happen

Get in touch with us on [email protected].

We need…


Building, maintaining and hosting a service like this costs.


Help us spread the word. Share the project and tip organisations, companies and individuals about us.

People and roles

  • Developers (we’re building this with Ruby on Rails)
  • Organisations that can maintain lists of bad accounts that should be blocked
  • Product managers
  • Digital strategists
  • Data analysts
  • Marketers

Hosting services

Hosting companies in the Ruby on Rails business… Any takers here?

Could be frequently asked questions

Who’s behind this?

Right now it’s just us — Kollegorna (Swedish for “The Colleagues”). We’re a digital agency building products and services.


Why do you need help AND money?

We can’t do it by ourselves.

Is this like X for Twitter?

Well… Like Truecaller for Twitter. Or AdBlock for Twitter. Or a traditional spamfilter. Or just a friend helping a friend out.

Is this affiliated with Twitter in any way?

No. But we hope to get their support.

Will Twitter allow this?

From what we can see we’re not breaking any terms. If this becomes as successful as we hope we’ll most likely reach the limit of calls to their API. If so we believe that the nice chaps at Twitter will let us pass anyway.

Are there more ways to join the cause against online harassment?

Yes there are:

Thanks for your time. Now let’s make Twitter more troll free. Contact us on [email protected] if you can help and please share the project.

Try Troll, Abort!

Follow us on Twitter

Next Story — 🙅 Social Media is Not a Strategy
Currently Reading - 🙅 Social Media is Not a Strategy

🙅 Social Media is Not a Strategy

It is not Marketing.
It is not Advertising.
It is not a Tool.

Social Media is Accelerated Friendship!

[📲 tweet👆 this!]

That time I crashed a wedding because of Twitter.

When we hear the words social media, our brain focuses on the technology, the buttons, the media part. We skip over the most important elements: the relationships, the people, the social part.

The true power of social media lies in this simple formula:

Social media is not good or bad; it just mirrors and magnifies the good😊 and the bad😳 in relationships: It can spread gossip and negativity like mean girls wearing pink on Wednesdays, or it can share encouragement and hope around the globe like Humans of New York. It just depends on what is in the heart of the user. Careful that your thumbs don’t launch words of mass destruction.

Facebook easily becomes a scene from Mean Girls.

🤔 How can it happen that two people do the exact same things on social media, but one person’s posts flourish while another’s struggle? This is because they started with different relationship equity, and the differences can exist both in the quality of their relationships, as well as quantity of them. The technology part amplifies the relationship part, not the other way around.

Don’t compare your social media journey with someone else’s: It is a myth that we all start with zero followers. One person begins their account with overflowing relationship equity, while another is relationally bankrupt. Each person will have different experiences and growth patterns.

When you start a new account (like me beginning this Medium account with this first post), your challenge is to transfer equity into that new platform. The number of followers is irrelevant: Followers can be bought, faked, and they mean nothing. Influence is what matters. Influence is earned.

👉 People over the age of 40 think they are at a disadvantage using social media, but this is just a bad 💩 mindset. The opposite is actually true. Age typically means more relationship experience and, hopefully, positive equity. One of our goals at Adventure Social is to teach people a more thoughtful approach to social media. Teaching the buttons is easy; being a good human — not so much.

My 👧🏻 daughter asked me the other day what I did for a living. I replied “I am a translator.” She asked, “What languages do you speak?”

“I speak nerd.” ~Dad
My daughter Pey Pey. FYI I’m building a bigger tower. 🐊

I translate technical jargon into the way people feel. For example:

  • A like = a high✋ five
  • A comment = a conversation (people fall in ❤️ love over conversations)
  • A share = 👏 word of mouth

When someone gets a notification that you like their photo, they don’t read it as [email protected] likes your photo”. They read: “I am important. I matter. Someone noticed me.”

Today, use social media to be a good friend. That is how you create true influence. Don’t be marketing, don’t be advertising, don’t be a tool.

Always your friend,

John-Erik 🤓🚀

This is my first Medium story. If you enjoyed these thoughts and you would like to hear more, I would pretty much be your 👫 BFF if you would recommend this story by lovingly pressing the heart ❤️👇at the bottom of this story.

What are some ways that we can be a good friend on social media? I’d love to hear your thoughts on this story and your ideas on how to accelerate friendship by replying 💬👇below.

Next Story — So You Want to be a Functional Programmer (Part 4)
Currently Reading - So You Want to be a Functional Programmer (Part 4)

So You Want to be a Functional Programmer (Part 4)

Taking that first step to understanding Functional Programming concepts is the most important and sometimes the most difficult step. But it doesn’t have to be. Not with the right perspective.

Previous parts: Part 1, Part 2, Part 3


If you remember from Part 3, the reason that we were having problems composing mult5 and add (in ) is because mult5 takes 1 parameter and add takes 2.

We can solve this easily by just restricting all functions to take only 1 parameter.

Trust me. It’s not as bad as it sounds.

We simply write an add function that uses 2 parameters but only takes 1 parameter at a time. Curried functions allow us to do this.

A Curried Function is a function that only takes a single parameter at a time.

This will let us give add its first parameter before we compose it with mult5. Then when mult5AfterAdd10 is called, add will get its second parameter.

In Javascript, we can accomplish this by rewriting add:

var add = x => y => x + y

This version of add is a function that takes one parameter now and then another one later.

In detail, the add function takes a single parameter, x, and returns a function that takes a single parameter, y, which will ultimately return the result of adding x and y.

Now we can use this version of add to build a working version of mult5AfterAdd10:

var compose = (f, g) => x => f(g(x));
var mult5AfterAdd10 = compose(mult5, add(10));

The compose function takes 2 parameters, f and g. Then it returns a function that takes 1 parameter, x, which when called will apply f after g to x.

So what did we do exactly? Well, we converted our plain old add function into a curried version. This made add more flexible since the first parameter, 10, can be passed to it up front and the final parameter will be passed when mult5AfterAdd10 is called.

At this point, you may be wondering how to rewrite the add function in Elm. Turns out, you don’t have to. In Elm and other Functional Languages, all functions are curried automatically.

So the add function looks the same:

add x y =
x + y

This is how mult5AfterAdd10 should have been written back in Part 3:

mult5AfterAdd10 =
(mult5 << add 10)

Syntactically speaking, Elm beats Imperative Languages like Javascript because it’s been optimized for Functional things like currying and composition.

Currying and Refactoring

Another time currying shines is during refactoring when you create a generalized version of a function with lots of parameters and then use it to create specialized versions with fewer parameters.

For example, when we have the following functions that put brackets and double brackets around strings:

bracket str =
"{" ++ str ++ "}"
doubleBracket str =
"{{" ++ str ++ "}}"

Here’s how we’d use it:

bracketedJoe =
bracket "Joe"
doubleBracketedJoe =
doubleBracket "Joe"

We can generalize bracket and doubleBracket:

generalBracket prefix str suffix =
prefix ++ str ++ suffix

But now every time we use generalBracket we have to pass in the brackets:

bracketedJoe =
generalBracket "{" "Joe" "}"
doubleBracketedJoe =
generalBracket "{{" "Joe" "}}"

What we really want is the best of both worlds.

If we reorder the parameters of generalBracket, we can create bracket and doubleBracket by leveraging the fact that functions are curried:

generalBracket prefix suffix str =
prefix ++ str ++ suffix
bracket =
generalBracket "{" "}"
doubleBracket =
generalBracket "{{" "}}"

Notice that by putting the parameters that were most likely to be static first, i.e. prefix and suffix, and putting the parameters that were most likely to change last, i.e. str, we can easily create specialized versions of generalBracket.

Parameter order is important to fully leverage currying.

Also, notice that bracket and doubleBracket are written in point-free notation, i.e. the str parameter is implied. Both bracket and doubleBracket are functions waiting for their final parameter.

Now we can use it just like before:

bracketedJoe =
bracket "Joe"
doubleBracketedJoe =
doubleBracket "Joe"

But this time we’re using a generalized curried function, generalBracket.

Common Functional Functions

Let’s look at 3 common functions that are used in Functional Languages.

But first, let’s look at the following Javascript code:

for (var i = 0; i < something.length; ++i) {
// do stuff

There’s one major thing wrong with this code. It’s not a bug. The problem is that this code is boilerplate code, i.e. code that is written over and over again.

If you code in Imperative Languages like Java, C#, Javascript, PHP, Python, etc., you’ll find yourself writing this boilerplate code more than any other.

That’s what’s wrong with it.

So let’s kill it. Let’s put it in a function (or a couple of functions) and never write a for-loop again. Well, almost never; at least until we move to a Functional Language.

Let’s start with modifying an array called things:

var things = [1, 2, 3, 4];
for (var i = 0; i < things.length; ++i) {
things[i] = things[i] * 10; // MUTATION ALERT !!!!
console.log(things); // [10, 20, 30, 40]

UGH!! Mutability!

Let’s try that again. This time we won’t mutate things:

var things = [1, 2, 3, 4];
var newThings = [];
for (var i = 0; i < things.length; ++i) {
newThings[i] = things[i] * 10;
console.log(newThings); // [10, 20, 30, 40]

Okay, so we didn’t mutate things but technically we mutated newThings. For now, we’re going to overlook this. We are in Javascript after all. Once we move to a Functional Language, we won’t be able to mutate.

The point here is to understand how these functions work and help us to reduce noise in our code.

Let’s take this code and put it in a function. We’re going to call our first common function map since it maps each value in the old array to new values in the new array:

var map = (f, array) => {
var newArray = [];
    for (var i = 0; i < array.length; ++i) {
newArray[i] = f(array[i]);
return newArray;

Notice the function, f, is passed in so that our map function can do anything we want to each item of the array.

Now we can call rewrite our previous code to use map:

var things = [1, 2, 3, 4];
var newThings = map(v => v * 10, things);

Look ma. No for-loops. And much easier to read and therefore reason about.

Well, technically, there are for-loops in the map function. But at least we don’t have to write that boilerplate code anymore.

Now let’s write another common function to filter things from an array:

var filter = (pred, array) => {
var newArray = [];
for (var i = 0; i < array.length; ++i) {
if (pred(array[i]))
newArray[newArray.length] = array[i];
return newArray;

Notice how the predicate function, pred, returns TRUE if we keep the item or FALSE if we toss it.

Here’s how to use filter to filter odd numbers:

var isOdd = x => x % 2 !== 0;
var numbers = [1, 2, 3, 4, 5];
var oddNumbers = filter(isOdd, numbers);
console.log(oddNumbers); // [1, 3, 5]

Using our new filter function is so much simpler than hand-coding it with a for-loop.

The final common function is called reduce. Typically, it’s used to take a list and reduce it to a single value but it can actually do so much more.

This function is usually called fold in Functional Languages.

var reduce = (f, start, array) => {
var acc = start;
for (var i = 0; i < array.length; ++i)
acc = f(array[i], acc); // f() takes 2 parameters
return acc;

The reduce function takes a reduction function, f, an initial start value and an array.

Notice that the reduction function, f, takes 2 parameters, the current item of the array, and the accumulator, acc. It will use these parameters to produce a new accumulator each iteration. The accumulator from the final iteration is returned.

An example will help us understand how it works:

var add = (x, y) => x + y;
var values = [1, 2, 3, 4, 5];
var sumOfValues = reduce(add, 0, values);
console.log(sumOfValues); // 15

Notice that the add function takes 2 parameters and adds them. Our reduce function expects a function that takes 2 parameters so they work well together.

We start with a start value of zero and pass in our array, values, to be summed. Inside the reduce function, the sum is accumulated as it iterates over values. The final accumulated value is returned as sumOfValues.

Each of these functions, map, filter and reduce let us do common manipulation operations on arrays without having to write boilerplate for-loops.

But in Functional Languages, they are even more useful since there are no loop constructs just recursion. Iteration functions aren’t just extremely helpful. They’re necessary.

My Brain!!!!

Enough for now.

In subsequent parts of this article, I’ll talk about Referential Integrity, Execution Order, Types, and more.

If you liked this, click the💚 below so other people will see this here on Medium.

If you want to join a community of web developers learning and helping each other to develop web apps using Functional Programming in Elm please check out my Facebook Group, Learn Elm Programming https://www.facebook.com/groups/learnelm/

My Twitter: @cscalfani

Next Story — Art for Change
Currently Reading - Art for Change

and truth; nothing more beautiful than truth. ©CKS

Art for Change

Collection of works regarding childhood abuse and domestic violence;
Not in publications.

Tell your story
without fear;
with hope;
by action and example
change becomes the inevitable.

CKS a.k.a The Crooked Little Flower
Twitter ~ Instagram ~ Website

©CKS, 2016

Next Story — An Open Letter from a Black Man to His White Family in a Moment of Violence
Currently Reading - An Open Letter from a Black Man to His White Family in a Moment of Violence

An Open Letter from a Black Man to His White Family in a Moment of Violence

Photo credit: Love and Struggle Photos

To the white people I share home with,

I’ve gotten degrees. I’ve been published. I’ve spoken at academic gatherings. I’ve taught classes and workshops. I’ve built up a resume. I’ve gained employment in the acceptable fields of social justice. For years, you told me these were the things I needed to do in order to be listened to.

I’ve participated in direct action. I’ve been arrested. I’ve survived nearly three decades in a country that hates me. I’ve predicted the formation of movements, the swell of riots, months and even years before their occurrences. I don’t know what else I need to do to be legitimized, be validated, to be worthy of being heard and taken seriously.

I am exhausted from trying to get you on board with a movement–one that mirrors those from previous eras you claim to revere, and that has reignited calls for social transformation once heralded by the writers, speakers, musicians and artists you claim to hold dearest. I wonder if you understand what any of the struggles which have occurred during your lifetime were ever actually about.

I am not naive nor arrogant enough to believe my imploring can achieve in this moment what centuries of Black imploring has not been able to. I am not foolish enough to believe this letter will be the letter that changes your minds. I write because I need to speak, because I am in pain. I write because I cannot bear any more condescension, more indifference. I write to tell you I am not going to.

The cry of this moment is Black Lives Matter. If you are not involved, I assume this is a statement you take issue with.

When we say Black Lives Matter, we mean Black people are the experts in their own lives, their own history, their own struggles. We mean your opinions are not necessary, and that debating you is a waste of our valuable energy, mental health and time. We mean you do not get to speak on issues with which you have no experience, which you have not studied nor researched, but on which you feel entitled enough to award yourself authority. We mean you must be quiet and listen to Black people.

You can no longer hide behind your idealism. The very existence of this moment proves your ideals to be misled and hollow.

If legislation alone could save us, the 13th Amendment, Special Field Order №15, and Brown vs. Board would have saved us. If electoral politics alone could save us, then the innumerable Black justices and representatives elected in the last half century would have saved us. If white saviors could save us, we would have been saved a million times over. But we are here and we are dying, and you are watching from the sidelines.

You call me an anarchist. You say you fear chaos. If you knew what it means to be Black, what is happening in your towns and cities daily, you’d know that chaos and bloodshed are already here. They are visited on women, on people of color, on poor people, workers, on immigrants, on trans people, on queer people, and they are done so constantly. Chaos is our bed, our sheets, our water, our front steps, our sidewalks. The systems you insist we trust to address it, the leaders you elected, are its source. Your fear of movement, and your denial of this reality, is what allows it to continue.

This is the last time I will say this to you:

Black people are dying. Every day, Black trans women are dying. Black children are dying. Black mothers and sisters are dying. Maybe I have to die for you to understand what this means.

If the demands of our movement are unclear to you, that is your fault. We have stated them concretely and concisely, over and over again–not just at this moment, but at every time in history Black people have fought for their lives. Don’t pretend that because the sources you read don’t report it, the information is unavailable. Don’t act as though your selective hearing is the result of our lack of organizing. Don’t tell the leaders who have penned the most passionate pleas for justice in US history they need to be more articulate.

And when the police come for me, don’t cry. When I am murdered by a supremacist in the street, don’t mourn me. If I am put in a cage for speaking out, don’t call it a travesty. Because it is happening, has been happening unceasingly for the last five centuries, and you have done nothing to stop it.

Do not feign shock at the inevitable. It disrespects me, and the memory of every Black person your system has purposefully killed.

When I tell you my needs, talk of my pain, my anger, all my stories, it is a privilege and blessing you haven’t earned. It is a profound form of vulnerability I engage not because you deserve it, but because I as a Black person choose to share it with you. I do so for the sole reason that I do not wish to lose you from my life, do not want the most core parts of my existence to be hidden from you. But when you refuse to look, they remain invisible. When you resist seeing, you deprive yourself of authentic entrance into who I truly am, and what I truly need from you.

And your denial cannot protect you, just as my silence cannot protect me.

This movement is happening without you, despite you. But real transformation is not possible unless you listen deeply, sincerely, even when it is painful, and take brave action at your own risk to fight for the things the Black community is demanding of you.

When Black people speak, and you do not listen, you are creating the conditions of a riot. And when you tell us we are exaggerating, playing the martyr, making it all up, then you cannot be surprised when we elect militancy to make you comprehend what you refused to understand when we were peaceful.

A son, brother, nephew and grandson of Black, queer liberation

Sign up to continue reading what matters most to you

Great stories deserve a great audience

Continue reading