A Thinking Sam @ITP

For Dan Shiffman’s incredible Nature of Code class at NYU ITP, I decided to build a Web-based aquarium that would tell the tale of the world’s fish populations over the last 100 years. See it in action at: http://athinkingsam.com/aquarium/

People hear how fish stocks are being depleted due to overfishing, but it’s difficult to understand the real magnitude of this decline. My project — the Nature of Overfishing — is a Web aquarium that tells the tale of the world’s fish populations over the last 100 years. While there was once big “predatory” fish and small “prey” fish in healthy proportions, overfishing has decimated our ocean’s big fish (i.e. the ones humans catch and eat) and left small fish populations overly abundant. The decline was modest until 1970, and then took a sharp and drastic turn for the worst. This digital aquarium is a data story, presenting the information visually. The data comes directly from a regression analysis by Dr. Villy Christensen and the renowned UBC Fisheries Centre.

Above all, I wanted to make this overfishing data more accessible by building a fun and visually catching Web aquarium. I chose to build it for the Web using ProcessingJS, JQuery, and some custom Javascript.

• You can see the full code here: https://github.com/sslover/the-nature-of-overfishing. You’ll want to primarily look at index.html, aquarium.pde, and application.js in the JS folder.
• You can find Dan Shiffman’s entire Nature of Code book here (this book is approachable and lots of fun… highly recommended!): http://natureofcode.com/

I am going to use this post to talk about some best practices in working in ProcessingJS and bringing in other Javascript elements (such as Jquery). All of this is easier then one might expect, although there are some ground rules that you basically have to abide by:

1. You cannot use Processing libraries. If you need a library, explore what Javascript and Jquery have to offer. There’s many comparable libraries that could be intertwined with your Processing sketch (however, this is more for supplemental aspects like audio or UI elements; libraries needed for the actual animation of your sketch are more tricky on the Web and I find are best avoided).
2. You’ll want to set all sizing and placement based on the browser Window size. No worries — Javascript makes this easy.
3. You have to be very conscious of how much you are drawing. I find it’s best to use Arraylists to easily remove elements of the sketch when they are no longer needed (and add new elements).
4. You should take advantage of Javascript and Jquery! They can bring lots of interactivity to your animation.
5. You should give the user a prompt if their browser can’t display the animation properly. Again using JQuery, you can detect browsers that don’t have the needed attributes to properly display a ProcessingJS sketch, and let the user know accordingly (for example, for browsers that don’t support Canvas or are very tiny).

Before I talk a bit about each of the above ground rules, I first want to address the question of “Why ProcessingJS?”.  In fact, when I started on this project, I initially considered using either Paper.js or D3.js. While both of these Javascript libraries are wonderful in their own right, I decided to go with ProcessingJS mainly due to how much easier it is to do complex animations and drawings. It is true that these other libraries CAN do complex animations as well (for example: http://paperjs.org/examples/tadpoles/), but the amount of work needed to produce a similar quality is a tad burdensome. Quite simply, ProcessingJS makes animations a cinch. You just need to be careful about the speed and functionality of your animation in the Web canvas-based environment. And with that, the following should hopefully help

Rule 1: No Libraries

Processing comes with some amazing libraries. Unfortunately, these won’t work in a Web-based environment. So if you’re making a sketch for the Web, don’t even think about using them. Instead, think about why you’d want to use a library in the first place. Usually, you’ll be able to 1. accomplish a similar objective without a library altogether (even if it means simplifying your concept a tad) or 2.  find a Javascript or Jquery equivalent that can work with your Processing sketch (especially if you need something supplemental like audio or UI elements). But really, for most things on the Web, you likely won’t need libraries.

Rule 2: Size EVERYTHING based on the detected screensize

This is an important one. When you’re developing a Processing sketch natively on your computer, there’s lots in your control. Perhaps most importantly, you control which system your sketch will run on. And as a result, you have some idea of the size of the screen. Unfortunately, life is not so easy on the Web. Computer screens come in all sorts of sizes, and you’ll probably want your animation to work on tablets too. But fear not! There’s actually a great solution here. Using Javascript, you can detect the height and width of the browser screen, set those detected sizes as global variables, and then set ALL sizings and placements in your sketch based on the detected sizes.

Check out this chunk of code  to see what I mean:

Rule 3: Monitor How Much You Draw

This is more of a thought process than anything else. There’s times we all want to go crazy and animate everything we can think of, but in a Web canvas environment, that won’t always work (in my aquarium, I initially animated some pretty badass sea plants, before realizing this would render the animation painfully slow on the Web). You’ll need to manage what you’re drawing somewhat meticulously. Using the Processing ArrayList, you can easily add and remove elements as needed. In particular, if an item leaves the screen or is otherwise no longer needed in your sketch, best to remove it. Pro tip: Println() the size of your Arrays and ArrayList until you push to production. That way, you keep track of how much you are exactly drawing.

Rule 4: Take advantage of Javascript and JQuery

And here we finally get to why ProcessingJS is so darn useful and awesome: it can be combined elegantly with other elements of the Web, particularly Javascript and JQuery. This, my friends, is a powerful thing. For example, in my aquarium, I use a JQuery slider to allow the user to toggle between years. When the slider is changed, the new value is passed to the ProcessingJS sketch (via a function), and the sketch is updated accordingly (in my case, fish fade in or fade out). While I certainly COULD have implemented my own slider in ProcessingJS, it would be akin to re-inventing the wheel. JQuery already has amazing UI elements, and these elements (like any other Javascript component), can talk to your ProcessingJS sketch quite easily.

Before I go on, I must reference the amazing (and definititive) guide by Pomax: http://processingjs.org/articles/PomaxGuide.html#jstosketch. Seriously, read it.

Now, let’s jump into the code in my aquarium that made the magic happen. It involves 1. a function in ProcessingJS (aquarium.pde) that can receive an argument and 2. a function in Javascript (application.js) that can communicate to the ProcessingJS function. The former is super simple, and the latter is what you’ll need to get a handle on. Check it out:

Rule 5: Prompt the User if their browser won’t properly show the sketch

Finally, we must accept that the Web is a whole different beast. The fact of the matter is that some users are going to try to access your animation with old browsers that lack Canvas (which is needed to display a ProcessingJS animation (and almost all Web animations for that matter)), or on mobile devices that are teeny tiny and may not be suitable in displaying your work (for example, while my aquarium works on mobile browsers, it lacks the same visual effectiveness). In these scenarios, it’s a good idea to create a pop-up modal window letting the user know that the visualization is not compatible with his or her browser.

Check out this tutorial for a very easy way to create a pop-up modal window with JQuery. Note that the window is hidden at first and ONLY shows if certain conditions are met (in our case, the browser lacks canvas or is below a certain size).

Here’s the code I created to trigger the modal:

And that’s it. ProcessingJS with JQuery and Javascript can be a great way to get your animations to the Web for the world to see. Follow the 5 rules above, and you’ll be in business.

For our Always On, Always Connected final project, Shilpan, Max and I are building an app we’re quite excited about. The idea is simple: you can leave invisible, geo-aware notes for your friends, family, and other connections. Every note has a specific location you’ve defined, and they don’t receive the note until they are in that specific location. It’s awesome. And it has the potential to make notes more meaningful because you are leaving the note in the specific place you want the person to read it. At the very least, it can be a lot of fun. Here is the initial wireframe:

Some use scenarios:

• Leave a note for your friend to find when she gets home
• Leave notes around the city for your connections to stumble upon serendipitously
• You are in New York, but your family and friends are in China or India. You can leave them notes to find in places you know they’ll be. Say, when they get to work in India.
• Leave a note for all members of a group. For example, Rob Ryan could leave a note for EVERYONE in ITP to receive the moment they get to the floor.

Our initial app hopes to have the following features:

• Log in through Facebook
• Add your Facebook friends to be connections on our App
• Leave geo-aware notes for 1 person or for a group
• Receive geo-aware notes that have been left for you (when you are in the defined location)
• See an inbox of the notes you have left and received
• Create groups with multiple people.

I recently played around with getting a basic OpenTok Android App up and running. There was a bit of a set-up process, which I’ll document here.

Things you’ll need:

• OpenTok Developer account: http://www.tokbox.com/
• OpenTok Android SDK: https://github.com/opentok/opentok-android-sdk
• OpenTok Android HelloWorld: https://github.com/opentok/Android-Hello-World
• Basic OpenTok Admin page to see incoming streams from the Android app: https://github.com/sslover/opentok-demo/blob/master/tokbox-admin.html. It will look like this: http://itp.nyu.edu/~sjs663/hack-ed/tokbox-admin.html

Step 1: The SDK and Hello World App

You’ll first need to take a download of the SDK and the HelloWorld App via the above links.

Once you’ve done that, import the HelloWorld App into Eclipse. You’ll need to do a few things to make sure it works properly:

• Make sure you have a Nexus 4, Nexus 7, or Galaxy SIII. Other devices are not currently supported.
• In Eclipse, right click the Project name and choose “Properties > Android > Android 4.2 API Level 17″
• Similarly, right click the Project name and choose “Properties > Java Build Path > Libraries” and go to Add JARs. Make sure that all the .jar files within the “libs” folder have been added.
• Do a project clean: Project > Clean

Step 2: Generate a Unique Session and Token for the App

Now, we need to give our App a unique SessionID and token.

Go to your tokbox account (http://www.tokbox.com/), and add a project. Once in the project, create a SessionID and then generate a token for that sessionID. Take this information (along with your API Key) and update the relevant entries on both the HelloWorld Android App and the Basic Admin page. Save everything and open the HTML file.

Now, start the App. The video should start, and in a second or two, you should see the live stream broadcast on the Admin Webpage.

Since my last update, I’ve been thinking a lot about how to design community into a new online platform. While I think most of the actual class experience can be accomplished via live video and discussion, that alone won’t create a thriving learning community that challenges, supports, and allows students to grow together.

My learning community has 4 pillars, which I’ll call the 4 Bs: Blogs, Badges, Buildings, and Bill of Rights & Responsibilities.

Blogs

In my new online learning community, each new student must create a blog and post the URL to the public class forum. There will be an initial class on how to set up a WordPress blog for those unfamiliar (but if someone wants to use Tumblr, Jekyll, or similar, that’s fine too, so long as there is an easy way for others to comment).

Everyone is required to have a blog for 3 reasons:

1. The act of posting to a blog helps one become an active and informed digital citizen.
2. When you post your work publicly to a blog, you are more likely to put in more effort and finish that work (because you know others will be looking at your blog and commenting, which is another requirement in my learning community).
3. The act of posting to a blog helps one organize his or her thoughts, which allows for greater clarity, and it also gives them a central place to go back and review what they’ve done at a later date.

Blogs are the key place to submit assignments, and it is a requirement that all students comment on the blogs of other’s.

Badges

Students are naturally more motivated when they receive some type of “proof” at the end of a class (we could argue that this is not true for everyone, but I personally believe it is hardwired into the human psyche to want to “earn” something at the completion of one’s work).

In my new online learning community, I will introduce Mozilla’s new Open Badge Framework. The Open Badge Framework is a standardized framework that allows learners to collect badges from various places and organizations, and then display them in a central digital backpack. Each badge has meta-data built in that links back to the issuer, the criteria the badge was issued under, and evidence verifying the credential. It is basically a new Web standard for credentialing learning outside of traditional schools. All of my classes will come with one of these badges.

Buildings

I am inspired by the floor plans of ITP and General Assembly that are purposefully designed to encourage day-to-day interaction (because people work and pass through common areas). This begs the question of how such a floor plan could be re-created in the digital realm. What is an online common area that all must pass through?

My idea is that each class is essentially its own forum. To get to the class content (videos, resource postings, links, etc.), you have to pass through the discussion area. Community leaders will be tasked with seeding and starting discussions in this area (to set an example for others to do the same).

Bill of Rights & Responsibilities

To get the most out of an online learning community, each learner must commit to a certain set of rights and responsibilities. In fact, it is even more important that online learners take the time to commit to these covenants because online communities take more of a concerted effort to thrive.

Before confirming his or her sign-up to the community, each student must commit to the following:

Your Rights & Responsibilities as an Online Learner

As a member of this online learning community, it’s important you commit yourself to a set of rights and responsibilities. This is necessary so both you and other members can participate in a thriving learning community that contributes to your personal and collective goals.

1. Log on to class at least 5 minutes early, ready to go at the indicated start time. Test the technology before-hand. Don’t assume you can log-in right at class time – you will likely be a bit late and this is not fair to yourself or your fellow learners.
2. Participate in class discussions. Just because you may not be in the same physical room as your fellow learners, does not mean you don’t need to talk to them. In fact, for the online community to achieve its collective learning goals, it’s even MORE important that we engage in class discussions together.
3. If you or someone else is experiencing a technology issue, take a deep breath, and help each other out. We’re in this together.
4. Respect your fellow learners. Contribute to class dialogues in a constructive and supportive manner.
5. Talk outside of class via the discussion forum. Learning doesn’t stop when class ends.
6. Post your work to your blog and comment on the blog of others. We all need feedback from time to time.

For the Nature of Code mid-semester project, I decided to delve deep into the land of Web animation via Javascript, and discover just how easy or hard it woud be to incorporate NOC concepts. With the help of a couple of libraries, I was able to create two projects that I quite like.

See them here:

• My personal website has a fun new playground. See http://athinkingsam.com and wait for the speech bubble. Click it for fun
• Bubbles! http://athinkingsam.com/itp/bubblesD3.html

Project 1: Box2D, Javascript and making Web elements fun
Code: https://github.com/sslover/box2D-javascript-playground

In approaching the project, one goal I had was to make standard Web elements into objects that could be played with by the user. Using the Javascript Box2D library and some tutorials, I was able to get a Box2D world working fairly easily in a canvas environment. Then, the trick was to make it so that each HTML div object (within a certain area) would be turned into a box. The code for that is as follows:

The resulting interaction can be seen here. Future work could involve creating static objects (for example, the top navigation could be a static box).

Project 2: NOC Bubble Animations in Javascript D3
Code: https://github.com/sslover/bubblesD3

I have become increasingly enamored with the Javascript D3 library. It’s generally used for beautiful in browser data visualizations and I’ve been meaning to explore it for some time. For an initial project, I wanted to see how tricky it would be to animate objects in Javascript D3, and then incorporate data into the animated objects. However, as it was my first time really going deep into D3, I achieved the former, but didn’t quite get the latter to work.

My initial idea was to create an in-browser “tweeting” fish: an animated fish that swims around and creates bubbles in its wake, and each bubble is a tweet. Eventually the fish could pull in the Twitter avatar from the user, so it would appear that a user has become the fish. While I got each individual component to work on its own (the fish swimming, the bubbles, and the tweets), combining them into one animation proved very difficult. As of right now, the bubbles are my favorite part (it’s like an in browser aquarium!): http://athinkingsam.com/itp/bubblesD3.html

This example pulls heavily from the “fluid resistance” example in Nature of Code, but flips around the gravity so that the bubbles are travelling up to the surface. Each bubble has a force and acceleration related to its mass, which is why large bubbles rise faster than smaller bubbles.

For our Always On midterm, Shiplan Bhagat and I created Styletapp, our first fully functional Android app. Styletapp allows users to keep track of the clothes they wear simply by tapping their phone to an NFC tag which is part of the clothing tag. The user’s home dashboard shows his or her clothing, along with information about how many times it’s been worn and when.

The code is available at https://github.com/sslover/styletappv1

The Problem:

People have a difficult time keeping track of their daily habits. Right now, to keep track of habits, you’d need to manually write down the information (by hand, or on your phone or your computer). That’s a lot of work.

Our Solution:

Styletapp makes it really easy for people to keep track of and broadcast the clothes they wear each day. We are starting with clothes because it is a daily ritual, and many people are interested in it. However, Styletapp could really be used to keep track of and broadcast any real world product.

The App and Interesting Android Learnings:

The app has the following components:

• A Home Dashboard that shows all the clothes added to date with information about how many times they’ve been worn and when. Users can choose to “Add an Item” or “Read an Existing Item.” Eventually, a sexy dashboard would be included on the home page to show habits.
• Adding an Item – when the user chooses to add an item, they simply give it a name, optional caption, type and brand, and then Add it to their Styletapp (eventually they would take a photo a la Instagram as well). The final step is tapping the phone to an embedded NFC tag on the clothing tag. That action gives the tag a unique ID which will permanently associate the tag to the clothing information.
• Reading an Item - Once an item has been added, each time the user wears it again, they simply have to “tap” it (no new information needs to be added). This action tells our system the item has been worn again, and returns the new information about the item.

Future Work:

• Photo Integration - Part of Styletapp is that the user can easily take a photo of the item after “tapping” it (and then the photo is associated with that item’s identity). We got the camera part working, but did not have time to integrate it with the rest of the app yet. We also need to post it to our Web server.
• Unique User Log-Ins - Right now, Styletapp is made for just 1 person to tag and keep track of their clothing. We need unique user identities so people can create their own accounts and track their own cloth-wearing ways.
• Social Share – After tapping, allow users to share what they’re wearing (this could really apply to any “shareable” entity — tap your phone to a product and then share it to the world).
• Expand to Other Products - As mentioned above, while we started with clothing because it is a daily ritual (and many people are into tracking and broadcasting their style), Styletapp could really work for any product. See something cool in a store? Tap it to get more information and share it with the world. It could also work really at events like SXSW or the ITP Show . See a cool exhibit or technology. Tap a specific part of the booth to get more info about the exhibit and share it with the world. Even better, it can allow people to keep track of the things they see and find compelling in the real world. By simply tapping, they have a permanent record of it.

For my midterm project, I’ll be collaborating with ITP colleague Shilpan Bhagat.

We’re really interested in exploring how we can use our devices to collect and show data in a meaningful way. We want to explore how that can happen in the context of someone’s daily routines, activities, and decision-making.

Here are our 2 concepts. We are leaning toward doing the former.

Clothing

There’s a lot of interesting data that can be used if we start collecting data on what someone wears (for example, dry cleaning reminders, sale suggestions, etc.). We are thinking of using an NFC application to track what someone wears and make suggestions based on it. All they have to do is tap their phone to their clothes, and our app will keep track of what they wear, when they wear it, and can make smart suggestions based on it (and show this data in an interesting way).

Food Label

Every food item in a store has a label, but that’s not really the “real” label anymore. Instead, the real label is all the information that exists about that food on the Web. We are considering creating an app that will allow people to see this “real” label. The user will either scan barcodes or take photos of the food, and will be shown a label that aggregates information about that food (likely through a crowd-source nutritional wiki). The idea is to be able to access a much better food label than what is currently offered.

In this week’s installment of Hacking Higher Ed, I had a fun and informative experience playing around with different video streaming systems. I played with Wirecast/Wowza, and then tested the Google Hangout and OpenTok APIs. I saw the Pros and Cons of each system, and came away with an exciting plan to combine live video with a discussion-based platform.

But first, on to my live-steaming experiments.

Wirecast/Wowza with an embedded chat (http://www.learnitlive.com/view.php?esession_id=282&provider_table=wow2_live)

I’ve been a big fan of Wirecast and Wowza for a few years now. It’s a very reliable system for easily streaming live video (and generating recordings in the process).

In fact, my company has been using Wirecast/Wowza to hold live classes for a couple years. People need to register for the class, and then they’re able to access a page like http://www.learnitlive.com/view.php?esession_id=282&provider_table=wow2_live. Building this page within our broader platform is nice, because it allows for an authentication system where only registered users can access the class page.

Using Wirecast/Wowza, we essentially have created our own virtual classroom by embedding different html and JS-based tools on a page:

• The live streaming video with Wirecast and Wowza Media Server
• An embedded chat where people can exchange dialogue, link to Youtube videos, take polls, send files, etc. (bottom right)
• An embedded Twitter feed for the class (bottom left)

And what’s nice is that after the live stream is over, a recording of the class can be placed on the page (so the class lives on as people watch the recordings).

An issue with this system is often you want more robust chat, screensharing, and a stronger classroom identity, and you want it all integrated together.

That type of system is exactly what Google Hangouts and Skype do really well, so I decided to play around with the Google Hangout API.

Google Hangouts (http://itp.nyu.edu/~sjs663/hack-ed/google-test.html)

You can easily use the Google Hangout API to create your own Hangout app that can act as your live classroom (and the API let’s you customize many aspects of the classroom itself). For example, I set up the start of a really basic class page at http://itp.nyu.edu/~sjs663/hack-ed/google-test.html. You can imagine this page filled out with all sorts of needed classroom components:

• A big button to enter the live classroom (which is just a Google Hangout app that I have written using their API). People simply click the button to join the live class at the correct time. I’m still not entirely sure how to limit who can enter (so it isn’t a free-for-all). Need to dig around the API more.
• Class information and syllabus
• Discussion Board / Forum
• Links to download or view class content (supplementary videos, docs, presentations, etc.)

The Google Hangout API is really good (and I truly believe Google Hangouts could be the future backbone of live/online education). However, there’s still a couple of issues:

• Class recordings. While you can record the Hangout class to Youtube, there could be times where you’d prefer to restrict the class video (rather than place it on Youtube where anyone can watch). Wowza/Wirecast gives you complete control in that regard.
• Single Sign-on. Ideally, you’d want users of your system to be integrated into the Google hangout with the same identity (i.e. I’m Sam in ITP, and when I join the class, my user details should be passed along so I have a seamless identity). The Google Hangout is more about entering with your Google+ ID.

But the above could actually work quite well for an online learning system. Simply require everyone that signs up to your service to have a Google+ account (and make them sign up to the site with that account), and you’re in business. Students coming into the classroom will have a consistent identity throughout your application: from class registration, to discussion postings, to the live classroom — they have the same Google+ identity.

However, there are legitimate reasons not to want to limit users to a Google-based system, so I also tested a more open video streaming platform.

OpenTok (http://itp.nyu.edu/~sjs663/hack-ed/tokbox-test.html)

I love OpenTok.

It’s a dead simple Javascript-based video streaming system that allows you to embed live streams on your page (but they are running on the OpenTok server, which is convenient). The API has everything I’m looking for in an embeddable live video tool:

• User authentication, so you can pass user details into the page
• Role authentication, so you can give some users broadcast privileges and others not
• It has code for both Web and Mobile compatibility. And if the browser supports WebRTC, it uses that.
• It has the ability to record and archive, and then playback via the same infrastructure

I’m quite intrigued by the possibility of OpenTok powering the video component of an online education platform. It seamlessly embeds on both Webpages and in Mobile apps, and can be combined with chat/discussion tools and user-authenticated systems. There’s a lot there.

Next Steps:

I’ve become really interested in combining a robust chat/discussion system with live-streamed video on the same page. I am envisioning a system where each course is essentially a forum, and each forum thread is a single class with a live stream video at the top (and then the class discussion takes place underneath). OpenTok looks ideal for the live video component. But I need a more robust discussion/chat platform.

And I’m in luck. An open-source real time discussion platform was just launched by the guy who created Stack Overflow. It’s completely open and can be customized to one’s needs (they want it to be the WordPress of discussion platforms). It’s called http://www.discourse.org/ and I’m planning to start playing around with customizing it to see if it could power a full-fledged school. My thesis is that live/recorded video (Open Tok) combined with a robust discussion platform (Discourse) is really all you need to power a a very effective online school. We’ll see.

For my Nature of Code assignment this week, I created an interactive Outkast video. By clicking the mouse, the user can make Big Boi and Andre bob to the beat, and fun special effects are produced in the background. The effects, color, and movement are all powered by Perlin Noise. All special effect objects are handles with PShapes, PVectors, and standard physics.

Code is available at https://github.com/sslover/natureofoutkast

Note: Check back for working JS version

We’re at a very strange crossroads with ubiquitous computing. On the one hand, the way technology now empowers us is remarkable; we essentially have the world’s knowledge and tools in our powerful little pocket computers. The emergence of ubiquitous computing has sparked social movements, allows people to stay connected in ways they never could have before, and has even been used in wars:

We recommend that no Hamas operatives, whether low level or senior leaders, show their faces above ground in the days ahead.

— IDF (@IDFSpokesperson) November 14, 2012

But on the other hand, we’ve gotten to this point so quickly that people seem like kids in a candy store, who have not yet learned to use the technology wisely and with restraint. Not to wax too philosophic, but many spiritual beliefs hold that the key to happiness lies in being truly present in the moment. And all too often, I see too many people entirely not present due to ubiquitous computing:

• The family dinner where everyone keeps glancing down at their phones, scanning the endless barrage of notifications that come in.
• The business / brainstorm meeting where people keep going back to the multiple tabs they have opened.
• The “vacation” where work comes with you and your phone.
• The concert, safari, hike, whatever, where you’re consumed with constant documentation and posts to the outside world, instead of enjoying the experience for what it is.

We’ve become really good at consuming media and being hyper-connected. But we have not yet developed the inverse capacity of restraint. When is the right time to use the wonderful tech that pervades our life? And when is better to put the phone away and stay present in the offline reality of the current moment? It’s not an easy answer of course, but I do think more tech applications should consider what is a healthy amount of use among its users (which I know goes against the very purpose of most apps… you want the user to stay glued). I personally believe our brains were not developed to process the dizzying amount of information that we now do, and I worry about what this means for our long-term health and happiness as a society.

The video below, while somewhat cheesy and over-produced, resonates with my viewpoint. Being unconnected has its benefits, and I believe true happiness can only come from allowing yourself this unconnectedness at least some of the time. Everything must happen in balance and moderation, connectivity included.