in the interest of trying to slightly curtail the domination of politics in ~news for people who don't care for it while also consolidating discussion for people who potentially do, i think we should try one of those weekly threads that's so hip and popular on the rest of tildes, so here we go: this is a test run of a weekly thread on 2020 presidential news/analysis/etc. it's probably not going to get any lighter from here, news wise, so it might pay to establish a recurring topic like this before the media really gets rolling with election coverage (and potentially before ~news becomes a deluge of 2020 topics).

i think common sense should be able to generally dictate what does and does not get posted in this thread if it works out, so i guess i'll just say: if it's big news or feels like big news, probably make it its own post instead of lobbing it in here. like the other weekly threads, this one is going to try to focus on things that are still discussion worthy, but wouldn't necessarily make good/unique/non-repetitive discussion starters as their own posts.

leading off (and demonstrating that there really is going to be no dearth of 2020 primary and election news about this despite this week being pretty quiet on that front):

from NBC - Why some Democrats say: Don't sleep on 'Mayor Pete' Buttigieg. buttigieg is a pretty small candidate in a field of big names, but that hasn't put the damper on people's optimism for him as this NBC piece shows. i personally don't think he's got the runway necessary for takeoff, but with the debates, who knows. it might be that the debates stratify the field even more than it's already stratified--or it might be that they level it out a bit, to the benefit of people like buttigieg

from Buzzfeed - The Romance Of Mayor Pete In The Season Of Scam. another piece on buttigieg. this one is a bit light on substance and is basically an opinion piece, but if you're curious about buttigieg's qualifications you might be interested in it.

from Heavy - Bernie Sanders’ Los Angeles Rally Draws So Many, Overflow Crowd Fills City Hall Steps Across the Street [PHOTOS]. bernie sanders made the second of three stops in california yesterday, and he drew a pretty major crowd that's currently estimated at around 15k--and could potentially be as high as 20k or 25k, depending on the setup of the venue. his stop the day before was in san diego where he drew a crowd of about 6,400, and today he'll be in san francisco, which could lead to an early messaging and marketing win if he can draw a comparable crowd to kamala harris's kickoff in oakland (which drew 20k).

from The Guardian - The B-Team: are Beto, Biden and Bernie the best Democrats can offer?. i'll let this one present itself: "...But three of the top-polling candidates for 2020 so far are white men: Vermont senator Bernie Sanders, O’Rourke and former vice-president Joe Biden, who has not even declared his candidacy. Does that present a problem?" one of the big criticisms of the democratic party is that, even as it diversifies its slate of candidates across the board, its biggest hitters generally remain white and male, especially in this presidential election. whether or not that's a particularly valid criticism, i'll leave up to you.

from POLITICO - Harris and O'Rourke go straight for each other's strongholds. sanders wasn't the only one buzzing around this week: o'rourke and harris have both been on tours of their own in states that will be pretty instrumental to the path of any democrat that wants to win the nomination. o'rourke, you may remember (tildes discussion), is the current day-one fundraising leader, and it appears we now actually have his individual donor numbers now (112,000, average donation of $55). so far, he doesn't appear to have parlayed that into particularly large crowd sizes (and outside of her campaign launch, harris hasn't really either) but we're still very early on, so i anticipate as their campaigns ramp up they'll start pulling larger numbers.

from NBC - Beto O'Rourke could be a threat — to Biden on his right and Sanders on his left. this article, as you can probably guess by its title, mostly focuses on how beto is trying to position himself in the primary, but also how some of the people he appeals to feel about his candidacy and why they support him.

lastly, from NPR - Small Donors Hold The Key To Campaign Buzz And The Democrats' Debate Stage. this NPR article on push by democrats to incentivize campaigns to build up their small donor bases in the leadup to 2020. the democrats have pretty much always been the undisputed champions of small-donor politics since the internet became a significant player in american politics, mostly on the back of things like actblue. nevertheless, there are still a lot of places they've been looking to improve (and it's really only a matter of time before republicans build infrastructure of their own), so it makes sense that they're really trying to shore up that advantage where they can while they can.

this isn't even every article that i could have tossed on here, but i've already been working on this post for like an hour, so i think that'll suffice for now. feel free to contribute other interesting articles or comment on some of the ones up there.

Pretty straight forward question, but basically I was watching a discussion panel the other day talking about the ethics of Self-Driving cars. A topic came up about people writing crappy code, and more than that, people not testing their code. And if they do, they do point testing. I am in my last semester of uni and I am working with some companies where we are doing pretty extensive testing, happy flows and a lot of alternate flows, as well as UI/UX testing. I wanted to extend this question to you, do you guys do testing, what type? How much do you focus on it? And if u love it/hate it?

Preface

Recently I briefly touched on the subject of cyclomatic complexity. This is an important concept for any programmer to understand and think about as they write their code. In order to provide a more solid understanding of the subject, however, I feel that I need to address the topic more thoroughly with a more practical example.

What is cyclomatic complexity?

The concept of "cyclomatic complexity" is simple: the more conditional branching and looping in your code, the more complex--and therefore the more difficult to maintain--that code is. We can visualize this complexity by drawing a diagram that illustrates the flow of logic in our program. For example, let's take the following toy example of a user login attempt:

<?php

$login_data = getLoginCredentialsFromInput();

$login_succeeded = false;
$error = '';
if(usernameExists($login_data['username'])) {
    $user = getUser($login_data['username']);
    
    if(!isDeleted($user)) {
        if(!isBanned($user)) {
            if(!loginRateLimitReached($user)) {
                if(passwordMatches($user, $login_data['password'])) {
                    loginUser($user);
                    $login_succeeded = true;
                } else {
                    $error = getBadPasswordError();
                    logBadLoginAttempt();
                }
            } else {
                $error = getLoginRateLimitError($user);
            }
        } else {
            $error = getUserBannedError($user);
        }
    } else {
        $error = getUserDeletedError($user);
    }
} else {
    $error = getBadUsernameError($login_data['username']);
}

if($login_succeeded) {
    sendSuccessResponse();
} else {
    sendErrorResponse($error);
}

?>

A diagram for this logic might look something like this:

+-----------------+
|                 |
|  Program Start  |
|                 |
+--------+--------+
         |
         |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|    Username     +--->+    Set Error    +--+
|    Exists?      | No |                 |  |
|                 |    +-----------------+  |
+--------+--------+                         |
         |                                  |
     Yes |                                  |
         v                                  |
+--------+--------+    +-----------------+  |
|                 |    |                 |  |
|  User Deleted?  +--->+    Set Error    +->+
|                 | Yes|                 |  |
+--------+--------+    +-----------------+  |
         |                                  |
      No |                                  |
         v                                  |
+--------+--------+    +-----------------+  |
|                 |    |                 |  |
|  User Banned?   +--->+    Set Error    +->+
|                 | Yes|                 |  |
+--------+--------+    +-----------------+  |
         |                                  |
      No |                                  |
         v                                  |
+--------+--------+    +-----------------+  |
|                 |    |                 |  |
|   Login Rate    +--->+    Set Error    +->+
| Limit Reached?  | Yes|                 |  |
|                 |    +-----------------+  |
+--------+--------+                         |
         |                                  |
      No |                                  |
         v                                  |
+--------+--------+    +-----------------+  |
|                 |    |                 |  |
|Password Matches?+--->+    Set Error    +->+
|                 | No |                 |  |
+--------+--------+    +-----------------+  |
         |                                  |
     Yes |                                  |
         v                                  |
+--------+--------+    +----------+         |
|                 |    |          |         |
|   Login User    +--->+ Converge +<--------+
|                 |    |          |
+-----------------+    +---+------+
                           |
                           |
         +-----------------+
         |
         v
+--------+--------+
|                 |
|   Succeeded?    +-------------+
|                 | No          |
+--------+--------+             |
         |                      |
     Yes |                      |
         v                      v
+--------+--------+    +--------+--------+
|                 |    |                 |
|  Send Success   |    |   Send Error    |
|    Message      |    |    Message      |
|                 |    |                 |
+-----------------+    +-----------------+

It's important to note that between nodes in this directed graph, you can find certain enclosed regions being formed. Specifically, each conditional branch that converges back into the main line of execution generates an additional region. The number of these distinct enclosed regions is directly proportional to the level of cyclomatic complexity of the system--that is, more regions means more complicated code.

Clocking out early.

There's an important piece of information I noted when describing the above example:

. . . each conditional branch that converges back into the main line of execution generates an additional region.

The above example is made complex largely due to an attempt to create a single exit point at the end of the program logic, causing these conditional branches to converge and thus generate the additional enclosed regions within our diagram.

But what if we stopped trying to converge back into the main line of execution? What if, instead, we decided to interrupt the program execution as soon as we encountered an error? Our code might look something like this:

<?php

$login_data = getLoginCredentialsFromInput();

if(!usernameExists($login_data['username'])) {
    sendErrorResponse(getBadUsernameError($login_data['username']));
    return;
}

$user = getUser($login_data['username']);
if(isDeleted($user)) {
    sendErrorResponse(getUserDeletedError($user));
    return;
}

if(isBanned($user)) {
    sendErrorResponse(getUserBannedError($user));
    return;
}

if(loginRateLimitReached($user)) {
    logBadLoginAttempt($user);
    sendErrorResponse(getLoginRateLimitError($user));
    return;
}

if(!passwordMatches($user, $login_data['password'])) {
    logBadLoginAttempt($user);
    sendErrorResponse(getBadPasswordError());
    return;
}

loginUser($user);
sendSuccessResponse();

?>

Before we've even constructed a diagram for this logic, we can already see just how much simpler this logic is. We don't need to traverse a tree of if statements to determine which error message has priority to be sent out, we don't need to attempt to follow indentation levels, and our behavior on success is right at the very end and at the lowest level of indentation, where it's easily and obviously located at a glance.

Now, however, let's verify this reduction in complexity by examining the associated diagram:

+-----------------+
|                 |
|  Program Start  |
|                 |
+--------+--------+
         |
         |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|    Username     +--->+   Send Error    |
|    Exists?      | No |    Message      |
|                 |    |                 |
+--------+--------+    +-----------------+
         |
     Yes |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|  User Deleted?  +--->+   Send Error    |
|                 | Yes|    Message      |
+--------+--------+    |                 |
         |             +-----------------+
      No |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|  User Banned?   +--->+   Send Error    |
|                 | Yes|    Message      |
+--------+--------+    |                 |
         |             +-----------------+
      No |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|   Login Rate    +--->+   Send Error    |
| Limit Reached?  | Yes|    Message      |
|                 |    |                 |
+--------+--------+    +-----------------+
         |
      No |
         v
+--------+--------+    +-----------------+
|                 |    |                 |
|Password Matches?+--->+   Send Error    |
|                 | No |    Message      |
+--------+--------+    |                 |
         |             +-----------------+
     Yes |
         v
+--------+--------+
|                 |
|   Login User    |
|                 |
+--------+--------+
         |
         |
         v
+--------+--------+
|                 |
|  Send Success   |
|    Message      |
|                 |
+-----------------+

Something should immediately stand out here: there are no enclosed regions in this diagram! Furthermore, even our new diagram is much simpler to follow than the old one was.

Reality is rarely simple.

The above is a really forgiving example. It has no loops, and loops are going to create enclosed regions that can't be broken apart so easily; it has no conditional branches that are so tightly coupled with the main path of execution that they can't be broken up; and the scope of functionality and side effects are minimal. Sometimes you can't break those regions up. So what do we do when we inevitably encounter these cases?

High cyclomatic complexity in your program as a whole is inevitable for sufficiently large projects, especially in a production environment, and your efforts to reduce it can only go so far. In fact, I don't recommend trying to remove all or even most instances of cyclomatic complexity at all--instead, you should just be keeping the concept in mind to determine whether or not a function, method, class, module, or other component of your system is accumulating technical debt and therefore in need of refactoring.

At this point, astute readers might ask, "How does refactoring help if the cyclomatic complexity doesn't actually go away?", and this is a valid concern. The answer to that is simple, however: we're hiding complexity behind abstractions.

To test this, let's forget about cyclomatic complexity for a moment and instead focus on simplifying the refactored version of our toy example using abstraction:

<?php

function handleLoginAttempt($login_data) {
    if(!usernameExists($login_data['username'])) {
        sendErrorResponse(getBadUsernameError($login_data['username']));
        return;
    }

    $user = getUser($login_data['username']);
    if(isDeleted($user)) {
        sendErrorResponse(getUserDeletedError($user));
        return;
    }

    if(isBanned($user)) {
        sendErrorResponse(getUserBannedError($user));
        return;
    }

    if(loginRateLimitReached($user)) {
        logBadLoginAttempt($user);
        sendErrorResponse(getLoginRateLimitError($user));
        return;
    }

    if(!passwordMatches($user, $login_data['password'])) {
        logBadLoginAttempt($user);
        sendErrorResponse(getBadPasswordError());
        return;
    }

    loginUser($user);
    sendSuccessResponse();
}

$login_data = getLoginCredentialsFromInput();

handleLoginAttempt($login_data);

?>

The code above is functionally identical to our refactored example from earlier, but has an additional abstraction via a function. Now we can diagram this higher-level abstraction as follows:

+-----------------+
|                 |
|  Program Start  |
|                 |
+--------+--------+
         |
         |
         v
+--------+--------+
|                 |
|  Attempt Login  |
|                 |
+-----------------+

This is, of course, a pretty extreme example, but this is how we handle thinking about complex program logic. We abstract it down to the barest basics so that we can visualize, in its simplest form, what the program is supposed to do. We don't actually care about the implementation unless we're digging into that specific part of the system, because otherwise we would be so bogged down by the details that we wouldn't be able to reason about what our program is supposed to do.

Likewise, we can use these abstractions to hide away the cyclomatic complexity underlying different components of our software. This keeps everything clean and clutter-free in our head. And the more we do to keep our smaller components simple and easy to think about, the easier the larger components are to deal with, no matter how much cyclomatic complexity all of those components share as a collective.

Final Thoughts

Cyclomatic complexity isn't a bad thing to have in your code. The concept itself is only intended to be used as one of many tools to assess when your code is accumulating too much technical debt. It's a warning sign that you may need to change something, nothing more. But it's an incredibly useful tool to have available to you and you should get comfortable using it.

As a general rule of thumb, you can usually just take a glance at your code and assess whether or not there's too much cyclomatic complexity in a component by looking for either of the following:

• Too many loops and/or conditional statements nested within each other, i.e. you have a lot of indentation.
• Many loops in the same function/method.

It's not a perfect rule of thumb, but it's useful for at least 90% of your development needs, and there will inevitably be cases where you will prefer to accept some greater cyclomatic complexity because there is some benefit that makes it a better trade-off. Making that judgment is up to you as a developer.

As always, I'm more than willing to listen to feedback and answer any questions!

A few people have expressed interest in my indoor, semi-automated growing setup so here's the lowdown.. In a corner of my workshop is a cupboard with a footprint of 1.6x1.2m, 2.2m high. This is insulated with a mixture of glasswool, foam board and expanding foam (depending on what I could install where), and lined with diamond pattern aluminumised mylar (the diamond pattern provides diffuse reflection to avoid hotspots).

Inside the cupboard I have 750W of full-spectrum LED lighting, a 500W oil-filled radiator, and a small fan to keep air moving around. There's a vent which pulls air from the outside and a extractor fan which also vents outside. Being able to pull cool air from the outside (even in summer) is extremely useful as the lights can put out quite a lot of heat.

My main growsystem is an Amazon low-pressure aeroponics system, and I've also got some airpots to do some soil-based growing in. Aero on the right, pots on the left. If you're not familiar with aeroponics, it's a system where the plants roots hang in open space and nutrient-rich water is sprayed or misted over them. High-pressure aero uses mist and low pressure uses sprayers. High pressure aero is currently one of the best known ways to maximise plant growth but low-pressure is pretty good too and you don't need anywhere near as much gear like pressure vessels and solenoid and so on. I just have an aquarium pump which drives the sprayers. In my experience aero is considerably more efficient than soil, non-soil media or other hydroponics - but on the other hand it's very twitchy. If your nutrient balance is off or your pH is wrong or worse, you pump fails - things can go wrong very quickly.

The airpots are totally new to me. People say they're good but I have no idea. I have a mixture of compost, perlite and coco coir to go into them so we'll see how that works out. I'm going to use organic nutrients only on them, I have some seaweed derived stuff which should be good throughout the entire grow process.

So that's the hardware, now on to the fun bit - the automation...

On top of the cabinet is a board hosting a Raspberry Pi model A - these days I'd use a Zero W but they didn't exist when I built this. In it's mostly-bare state the board looks like this. Quick explanation - the red board is mains-rated relays which let me switch the connections above it on and off using the Pi. This is where the lights, fan and heater are wired to. The small junction block left of the relays is connected to mains.

The block up and left of the Pi is 5V, which drives the Pi, the relay control electronics and provides power to the junction block on the right. There are various sensors wired in to that block and connected back to the Pi.

Wired up on my bench for testing it looks like this, and in situ it looks like this (this was on a previous iteration of the cupboard but it's basically the same now). The orange cables on the left are lights, fan and heater. The black cables top are the sensors.

Temperature is monitored using five DS18B20 sensors, which are cheap and reasonably accurate serial devices so you can run a whole bunch of them off a single pin on the pi. I monitor my water temperature, the temperature at the plant stem, at the wall, inside my workshop (but outside the cupboard) and outside temperature. The wall/stem temperature is the important one, that determines whether heating or cooling is engaged. I monitor the exterior and interior temperatures to know how effective my insulation is being. If water temperature gets too high I might add an agent which protects against microbial infections that like warmer water.

I do have a DHT22 humidity sensor but they're hella flaky and it's currently not working. I will replace it at some point but past experience suggests humidity is high whatever I do.

The Pi has a python script which runs every five minutes. It reads all the sensors, decides what (if anything) to do, then logs everything in a sqlite database. If it's 'night' (which is actually day outside, for temperature management reasons) it turns the lights off, if it's 'day' it turns them on. If it's cold it turns the heater on, if it's hot the fan. There's a bit of smartness where it actually aims for a midpoint of temperature because otherwise it's always aiming for highest temperature then immediately cooling again, then heating and so on - a stable temperature is better for the plants. At 'night' I tend to run the fan to drop the temperature: plants often like it cooler during darkness, get some fresh air in and attempt to lower the humidity a bit.

There is a web interface which lets me see what's going on - current temperature and status, plus some lovely lovely charts (who doesn't love a nice chart?). I can also turn the lights out from here in case I need to go in an do some maintenance for anything. 750W of LED light is painfully bright, it's much more comfortable (and safer!) to turn them off while topping up reservoirs or changing water or whatever.

It would be relatively trivial to add sensors for moisture or pH to add an auto-watering or auto-adjusting nutrient systems, but I haven't felt the need to do that yet.

Happy to do my best to answer any questions anyone has.

I've been meaning to make this post for a while, and it's actually going to wind up being a series of several posts. It's kind of a long meditation on what it means to socialize online and the ways in which the services we use to do that help or hinder us in doing so. Along the way I'm going to be going into some thoughts on how online discourse works, how it should work, and what can be done to drive a more communal, less toxic, and more inclusive of non-traditional (read: non-technical) voices. I'm going to be throwing out a lot of inchoate opinions here, so I'm hoping to pressure test my views and solicit other viewpoints and experiences from the community.

I mentioned in an introduction thread that I'm a policy analyst and my work is focused on how to structure policies and procedures to build a constructive organizational culture. I've been a moderator in some large PHP forums and IRC channels in the old days, and I've developed some really strong and meaningful friendships through the web. So I've always had a soft spot for socializing on the interwebs.

Okay, so that's the introduction out of the way. The main point I want to focus on is the title: Remember the Person. This was the something Ellen Pao, former CEO of Reddit, suggested in a farewell message as she stepped down from the role in the wake of a community outcry regarding her changes to Reddit's moderation practices. The gist of it was that online communication makes it too easy to see the people you're interacting with in abstract terms rather than as human beings with feelings. It's a bit of a clichéd thought if we're being honest, but I think we still tend not to pay enough attention to how true it is and how deeply it alters the way we interact and behave and how it privileges certain kinds of interaction over others. So let's dig in on how we chat today, how it's different from how we chatted before in discussion forums, and what we're actually looking for when we gather online.

Since this is the first in a series, I want to focus on getting some clarity on terms and jargon that we'll be using going forward. I'd like to start by establishing some typologies for social media platforms. A lot of these will probably overlap with each other, and I'll probably be missing a few, but it's just to get a general sense of categories.

To start with we have the "Content Aggregator" sites. Reddit is the most notable, HackerNews is big but niche, and Tildes is one too. This would also include other sites like old Digg, Fark.com, and possibly even include things like IMGUR or 9Gag. The common thread among all of these is user submitted content, curation and editorial decisions made largely by popular vote, and continued engagement being driven by comment threads associated with the submitted content (e.g. links, images, videos, posts). In any case, the key thing you interact with on these sites is atomized pieces of "content."

Next up are the "Running Feed" services. Twitter and Mastodon are the classic examples as is Facebook's newsfeed. Instagram is an example with a different spin on it. These services are functionally just glorified status updates. Indeed, Twitter was originally pitched as "What if we had a site that was ONLY the status updates from AOL Instant Messager/GChat?" The key thing with how you interact with these services is the "social graph." You need to friend, follow, or subscribe to accounts to actually get anything. And in order to contribute anything, you need people following or subscribing to you. Otherwise you're just talking to yourself (although if we're being honest, that's what most people are doing anyway they just don't know it). This means the key thing you interact with on these sites is an account. You follow accounts get to put content on your feed. Follower counts, consequently, become a sort of "currency" on the site.

Then you've got the "Blogs" of old and their descendants. This one is a bit tricky since it's largely just websites so they can be really heterogenous. As far as platforms go, though, Tumblr is one of the few left and I think LiveJournal is still kicking. Lots of online newspapers and magazines also kind of count. And in the past there were a lot more services, like Xanga and MySpace. The key thing you interact with here is the site. The page itself is the content and they develop a distinct editorial voice. Follower counts are still kind of a thing, but the content itself has more persistence so immediacy is less of an issue than in feed based paradigms where anything older than a day might as well not exist. This one gets even trickier because the blogs tend to have comment sections and those comment sections can have a bunch little social media paradigms of their own. It's like a matroishka doll of social platforms.

The penultimate category is the "Bulletin Board" forum. PHP BB was usually the platform of choice. There are still a few of these kicking around, but once upon a time these were the predominant forms of online discourse. Ars Technica and Something Awful still have somewhat active ones, but I'm not sure where else. These also have user posted content, but there is no content curation or editorial action. As a result, these sites tend to need more empowered and active moderators to thrive. And the critical thing you're interacting with in these platforms is the thread. Threads are discussion topics, but it's a different vibe from the way you interact on a content aggregator. On a site like Reddit or Tildes all discussion under a topic is 1 to 1. Posts come under content. On a bulletin board it works like an actual bulletin board. You're responding under a discussion about a topic rather than making individual statements about an individual post or comment. Another way to put it is on an aggregator site each participant is functionally writing individual notes to each other participant. On a bulletin board each participant is writing an open letter to add to the overall discussion as a whole.

And finally, you've got the "Chat Clients." This is the oldest form besides email newsletters. This began with Usenet and then into IRC. The paradigm lives on today in the form of instant messaging/group texts, WhatsApp, Discord, Slack, etc. In this system you're primarily interacting with the room(s) as a whole. There isn't really an organizing framework for the conversation, it's really just a free-flowing conversation between the participants. You might be able to enforce on-topic restrictions, but that's about as structured as it gets.

That about covers the typologies I can think of. Next up I want to delve into the ways in which the UI and design patterns with each of these platforms affects the way users engage with them, what sorts of social dynamics they encourage, and what sorts of interactions they discourage. In the mean time, I'm eager to hear what people think about the way I've divided these up, whether you think I've missed anything, or have any additional thoughts on the ones I put up.

Is anyone here taking online courses e.g. Udacity, Coursera, Udemy, etc.? I just finished the Udacity AI Programming in Python course not long ago, and it was with a bit of gnashing of teeth towards the end. :[ The funny thing is, it wasn't (just) because it was technically challenging, but mostly learning-related anxiety and procrastination.

I'm curious about what others in the Tildes community are learning via massive open online courses (MOOCs), and what you think about them.

• How have online courses helped your career/personal goals (or did not meet expectations)?
• What do you think can be done better by these course providers or other entities?

In a meta-sort of way, I'm building a platform called MindsMatch help other learners finish their online courses faster. We are looking for users to alpha-test if you are interested!

<?php
// Variables
$username = 'your_username';
$password = 'your_password_super_long_and_unique';
$filename = 'path_to_private_folder/vnc/pin.txt';

// Process the login form
if($action == 'Login'){
	$file = fopen($filename,'w');
	$passwd = rand(100000,999999);
	fwrite($file,$passwd);
	fclose($file);
	exit('Success');
}

// Process the bash script
if($action == 'bash'){
	if(file_exists($filename)){
		$file = fopen($filename,'r');
		$passwd = fread($file,filesize($filename));
		fclose($filename);
		unlink($filename);
		exit($passwd);
	} else {
		exit('No_PIN');
	}
}
?>

I have a slight struggle that I wonder if anyone else can relate to. I'm a creative "type" in that both my job (scientist) and hobbies (many, over the years) require constant innovation, in addition to the usual labor, to keep them going.

I have a note/journal app where I store my ideas. Sometimes these are ideas with acute utility e.g. an experiment design that I can test out the next day at work or maybe an idea for a paper. Other ideas are what I would consider "highdeas" - insights or thoughts that seem amazing when you're stoned but after you sober up they're kind of nonsense. The former are productive and the latter are non-productive forms of creativity (barring any offshoots of the latter that prove useful later on).

But then sometimes I get idea in-between. Say, an insight into how certain human behaviors are a certain way or maybe a rant on a topic/issue in my lab work that is interesting but not valuable enough to publish or bring up in a formal meeting. My question / discussion topic for you, is, what do you do with these sort of self-ascribed interesting ideas that have no immediate value? One option is to write them out on a forum, as I am currently doing, but I would end up writing all day. Does anyone else keep track of these? Do you schedule a follow-up with these intermediate ideas for future inspiration? I currently use Joplin which is great but I don't think there are any features to stimulate creativity in this manner.

You are shit beautiful

Header text ## header text

Header text

Smaller header

Lorem ipsum

Two lines

italics
bold

• oh my god

• oh my

• oh

I am quoted

Separate this pls

from this

U r valuable. Pls donate ur kidney.

Testing it out. Trying some formatting!
New line, only once!

New line, twice!
New line, previous having two spaces!

Asterisks! Underscores! ~Tildes!~

Backtick!

triple backtick!

four spaces at the start of the line!

Hey! Lately I've decided that after years of wanting to do stuff on the internet, I'm gonna try my best to start streaming video games. I'm rather excited to start trying to form a lil community and I wanted to know if anyone here has tips/experience they would like to share. Any and all advice is welcomed and appreciated! I did a little test stream of Bioshock (using OBS) for some friends, but I'm currently using a wireless adapter so it didn't go very well for very long. I'm definitely picking up an ethernet cable before I try again. But in the meantime, I thought I'd ask for some wisdom.

so i've just recently learned about this guy, and his work is quickly becoming a favorite of mine.

i'm admittedly crazy poorly-read (is that the antonym to well-read?) when it comes to...

well, anything besides self-help books released up to "The Subtle Art of Not Giving a Fuck" by Mark Manson.

and his work has been concise and just fucking accurate enough for me to enjoy.

so i present you all,

a journey through love, with Richard Brautigan.

-2

Everybody wants to go to bed

with everybody else, they're

lined up for blocks, so I'll

go to bed with you. They won't

miss us.

in this first stage, we see that little Richie's met himself someone special, and off they go arm in arm to live happily ever after.

Romeo and Juliet

If you will die for me,

I will die for you

and our graves will be like two lovers washing

their clothes together

in a laundromat

If you will bring the soap

I will bring the bleach.

and here we see something that, personally, i found surprising from a poet who got his start in the 50s.

this piece emulates the incendiary, passionate, limitless love that some of us have been lucky enough to experience in the early years of our lives. the love where it's the both of you against the world. the love where the most mundane tasks seem incredulous solely because they're done together. the love that i have only seemed to find in life, through trauma bonding.

their love is powerful. their love is radiant.

I Feel Horrible, She Doesn't

I feel horrible. She doesn't

love me and I wander around

like a sewing machine

that's just finished sewing

a turd to a garbage can lid.

their love is over.

the crass yet poignant imagery somehow simultaneously flashing feelings of uselessness, self-loathing, and loss.

you are here.

Haiku Ambulance

A piece of green pepper

fell

off the wooden salad bowl:

so what?

the sheer stoicism here is inspiring to me.

this is the mindset that i want - and don't have the emotional energy to cultivate.

were Brautigan still around and kickin' today, i'd buy the man a shot of the best whiskey i could get with $7 and thank him for emulating the exact mindset i want, need, and desire

in four lines.

it's simple - the green paper is a fraud, illusory. from afar or even from near with a quick glance - the green paper is another leafy green of the salad. a leaf of lettuce, a bit of cabbage. even if you press your face into the bowl and smell, the paper will smell of salad and nothing but.

it falls onto the floor, you pick it up to throw it away. you notice the texture inapropos with more roughness, and frailty than a leaf of a vegetable. you test it - you tear it.

it was paper.

it was not the spinach you'd desired.

it was not real.

it was not what you wanted.

regardless of the time you've spent preparing the salad, chopping your veg, blending your dressing, tossing it all, and fixing it for presentation,

if you throw this paper out - it will be no loss, and your salad will only be better for it.

a green piece of paper fell off the wooden salad bowl.

so what?

Love Poem

the piece that brought Brautigan in to my attention in the first place.

It's so nice

to wake up in the morning

all alone

and not have to tell somebody

you love them

when you don't love them

any more.

resolve.

clarity.

peace.

the earlier bleach has gone unsipped. she has come, she has gone. he has suffered, he has grown.

and now, he is at peace.

his world back to...

normal.

this has been a journey through love with Richard Brautigan.

Every year we try to put together a 'best of' list that is devoid of the same 200 albums that make up all of the other music lists on the internet. We do this by intentionally excluding popular/mainstream artists from our submission pool. Our cutoff is generally no more than three tracks with a million plays on spotify, though we do fudge it a bit especially for artists that only have regional success or put out something really great. The popularity limits are more of a guideline than a hard and fast rule.

I used last year's results as a test post on tildes, if you want to see what the final results will look like. Once we finish voting on the albums we generate the playlists on spotify and use automated tools to replicate them to other streaming services. We have a google spreadsheet that helps us manage the process. There's a submission form that will drop recommendations right into the spreadsheet where we can work on them.

We're not trying to find albums that are 'better' than the mainstream. We're just trying to include more of the great music that gets released every year, particularly the good stuff from new and overlooked artists that gets lost by the wayside while all the major music publications argue about the right order of the year's press darlings. Consider AlbumOfTheYear's List as the 'official' record of what's popular in the music press.

We do this by asking people for their favorites - in listentothis, in letstalkmusic, and today here on Tildes. I'd like to invite everyone on Tildes to submit their picks for the best overlooked music they've heard this year.

How do you know if an album you like is good enough? Everyone has their own way of listening, but generally, if you've had the record on repeat at all, that's the sign that it's worthy of attention. If you've got one you can't stop spinning and can't get out of your head, that's 'must listen' territory which goes at the top of the list. Make sure to leave a note in your comment when you submit, if you think it's that good. ;)

You can submit albums right here using this form. Please put a ~ in front of your username when you submit, so we know it came from a tildes user rather than a reddit user.

This spotify playlist contains the 175 albums from 2018 we've gathered so far. That's what's in our spreadsheet right now, at the start of the process. We haven't vetted/voted on these yet, just made sure they come in near the popularity cutoff. If any of the albums in this list really knock your socks off, let us know in the comments below. The first 1/3 of the list is mostly from random redditors, quality may be a bit dicey. The last 2/3 is the fruit of the l2t crew's cratedigging all year, submissions from our 30+ moderators. Every genre you can imagine (and some you can't) is in this list, they aren't sorted by style yet - this is one big bucket that goes all over the map.

I will update this playlist as new albums come in, though not exactly in real time - expect a day or two delay. If you want to keep up with it, just follow that list on spotify.

We're taking until the end of Feb. to finish the 2018 set, so roughly 6-8 weeks to listen to all of this stuff before we push the finished set out the door. If you want to help us listen, bookmark this thread here on Tildes, and leave a comment here when one of the albums grabs you. Feel free to submit new albums to that spreadsheet right up until the deadline at the end of Feb.

Happy listening. :)

It's usually a question with a two word answer, but I'm sure there's more that could be said - that you wouldn't normally say because you don't want to waffle on.

Either way, I'm elated and excited. I revised a few hours for a test instead of watching a TV show, and my result went from shit to actually pretty bloody great. I'm really happy about it, but I'm not going to revise until GCSE's because it's made me absolutely knackered.

I'm pretty excited because I've got work experience next week. I haven't the foggiest about what it'll be like (fearing a very, very boring week), but I'm looking forward to it. It'll probably be a bit awkward without my friends around, but I'll get used to it.

So, onto you. How are you?