23 years ago today Tim Berners Lee proposed to invent the web
Pretty amazing.
http://www.w3.org/Proposal.html
DEAR READER

#extradirty

@theartofmadeline

Origami Around
Alisa U Zemlji Chuda
ojovivo

if i look back, i am lost
$LAYYYTER
"I'm Dorothy Gale from Kansas"

JVL
Sade Olutola
🪼
Stranger Things
let's talk about Bridgerton tea, my ask is open
Acquired Stardust


oozey mess

seen from United States
seen from United Kingdom

seen from T1

seen from Türkiye
seen from United Kingdom

seen from United States
seen from Malaysia

seen from Germany
seen from South Korea
seen from Chile
seen from United States

seen from Malaysia

seen from Malaysia
seen from United States
seen from Egypt

seen from Lithuania
seen from United Kingdom
seen from United States

seen from United States
seen from Chile
@samyangblogs
23 years ago today Tim Berners Lee proposed to invent the web
Pretty amazing.
http://www.w3.org/Proposal.html

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
FASTER FIVE ...on OSX
OSX has some pretty handy shortcuts that a lot of users (especially those super adept at keyboard shortcuts and terminal) sometimes forget. Here are a few of my favorite time savers.
Spotlight calculator. You can use spotlight to do super quick math. Hit ⌘cmd + SPACEBAR for Spotlight. Type in your math query for results (e.g., "5 + 10 / 2 * 30").
Spotlight dictionary. One of my favorite time savers is the dictionary/thesaurus built into spotlight. Hit ⌘cmd + SPACEBAR for Spotlight. Type in a word, then hit ⌘cmd + D. Voila! Use ⌘cmd + 1, ⌘cmd + 2, and so on to toggle references.
Use Activity Monitor to un-slow down your computer. Sometimes a program or two goes rogue and starts heavily taxing your system of its resources. You can tell your computer's resources are taxed if your Mac (1) is running slower than usual, (2) has its internal fan blowing hot air at full throttle and/or (3) you get lots of beach balls of death (aka: rainbow marbles of doom)
. If you don't like your resources being taxed, use Activity Monitor to look for apps or processes that have gone rogue and dispatch them as you'd please. First, hit ⌘cmd + SPACEBAR for Spotlight. Type "activity monitor" and hit return when the app's name pops up (usually within a few keystrokes). You'll see this:
Check the CPU usage by clicking ⌘cmd + 1 then clicking the "% CPU" column to sort by highest CPU cycles. If you have an app using up a lot of CPU (often Chrome with many tabs) AND it's a program you know can be shut down and restarted (like Chrome), try shutting it down. You can also trouble shoot any slowdowns with the other tabs resource tabs. Use ⌘cmd + 1 , ⌘cmd + 2 , and so on to toggle between them. Apple provides documentation on using Activity Monitor here.
Preferences. This one's pretty simple. Access the preferences for any app by entering: ⌘cmd + ,
Quickly disable or view notifications. If you ever want to temporarily shut off all notifications really quickly, just hold down the ⌥option button and click the notification icon at the top right of your menu bar. If you view your notifications often, here's a slick way to view all your notifications quickly. Put your index and middle finger by your trackpad like so...
...then swipe slowly left.
FASTER FIVE ...on Terminal/Bash
I love productivity tips and tricks, so I've decided to post a series of tips starting with this one for Terminal / Bash. Just open up your terminal and try the commands below. They're pretty cool.
Calendars in your terminal window? Whuuut??? To view the current month:
cal
To view a year:
cal 2013
To view a specific month:
cal 7 1776
Access your terminal command history. Last 500 commands:
history
Redo a command in your history:
!<number in history>
(examples: "!309" "!12" ) Search for specific commands:
history | grep <search string>
Return to your last directory. Ever find yourself wishing you could either undo your last "cd" or just simply go back to the last directory you were in? Well, you can. Just type:
cd -
Chain your commands. Use
&&
to chain multiple commands together. This is really useful if you want your computer to do a bunch of stuff while you take a quick break or if you want to create macros by aliasing any chain of commands.
Return last value in terminal. IRB can return the last value with
_
In Terminal, you can do the same thing with
!!
Part of getting out into the real world post Code Academy means collaborating with others on projects, working with existing production code, and absolutely despising git. First off, git is incredibly opaque as a language, the syntax is weird and it is very difficult to figure out what is going...
For beginners who are still getting used to using git, here are some great tips:
THE IRON THINKER. An “Hour Drawing,” available to purchase here, and the 200+ set of them so far here. Subject suggestion for this one was “The Iron Giant.”
This is awesome

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
Ruby Beginner tips for test-driven debugging
For some beginners, debugging can be a weary chore. It can lead to a lot more questions than answers. It can waste time and seem endless.
Throw test suites into the mix and, for a beginner, the result can be a volatile debugging process where the nuts and bolts of your code can appear to rattle apart at the seams. It can suck.
There's no substitute for hard work here. Beginners need to invest many hours before feeling comfortable whether it’s for debugging or for test building activities. With that said, a few rules and tips can make it easier to add test-driven methodology into your coding and debugging processes.
You might ask, "Why should a beginner learn about testing and complicate an already challenging learning process?"
That's a great question for which I offer four reasons.
.
--4 WHYs---
1. Everybody's doing it.
Assuming you want to have a career in programmer or do a tech start up or code as a hobby, test-driven development has become de rigeur. You need to know how to work with tests, and that means write them, fix them, use them, and debug with them. You'll need to know the development cycle and how unit testing (typically the sort of testing you'll be doing alone on your personal code) fits into the bigger domain of QA.
At the previous company I worked for, I help manage QA which involved managing a suite of tests including smoke tests, functional tests, black box and white box tests, integration tests, load tests, acceptance tests, and on and on. The point is that testing is a critical component of the development cycle, and your unit test is just the first and most atomic part of these tests you'll want to perform.
2. It saves time on debugging.
If you want quality code, and you want it fast, test it as you write it. Doing this will speed up the development of quality code. It helps eliminate coding artifacts and bugs from creeping in and breaking parts of your core base code, thus saving tons of time in your debugging process. You don't see this and it isn't apparent but trust me - it saves time.
Testing does this by providing a fast feedback loop that allows you to see if and where things go wrong in your code base. As you make changes to your code, functionality that used to work before can break without you knowing. You don't want that. You want to be able to know as frequently as possible that the things you do don't accidentally break your base code.
It may seem counter-intuitive since you're spending extra time writing tests - but you have to sacrifice a short term loss for long term gains - gains which will compound exponentially as time goes on.
3. It saves time on documentation.
This one's simple. Well-written tests serve as drafts of your product documentation thus killing two birds with one stone. In many cases, the tests actually serve as the documentation proper.
4. It shows you're responsible.
No one likes sloppy code. What better way than showing that you're a responsible, conscientious programmer who cares about the quality of your code than to adopt test-driven methods and practices?
5. Bad habits are harder to break than good habits are to learn.
Learning to test as you code is especially important to beginners because it’s easier to learn new habits correctly than to undo and change bad ones later.
For the first 500 hours of learning Ruby, you're going to be constantly feeling challenged so there's little upside in waiting until you reach a plateau of comfort to adopt testing into your coding process. Adopt it early. Adopt it now.
The only time you shouldn’t use tests when coding is when you're writing throw-away code: stuff like quick and dirty prototypes, sketches, etc.
Here a couple of good blog posts on testing:
http://www.codeenigma.com/en/blog/introduction-test-driven-development
http://www.jamesshore.com/Blog/Lets-Play
.
---3 HOWs---
The instructions below seem like common sense (because they are), but because many beginners tend to ignore vital tools in the test-driven debugger's arsenal, it's important to be super clear that each tool and tip listed below are important. Don't ignore any.
1. Use Rspec.
Rspec is, at this time, probably the best test suite out there for Ruby. In bash, do a 'gem install rspec' and follow instructions here. http://rspec.info/
2. Set up four quick-toggle windows
Once you're set up and you have an rspec to test your code against, set up your environment so that you can quickly and easily toggle between the following four screens:
Your code in your text editor
The corresponding rspec code in your text editor
An open bash window to run your rspec tests
An open pry or irb window to play around with errors quickly
I like to have all windows open in four quadrants on a single screen so that everything I need to toggle to is visually there. Here's what mine looks like:
https://dl.dropboxusercontent.com/u/88495/my_workspace.png
3. Use ALL FOUR windows to debug.
Over time, trust that you'll develop strong instincts to hone into the errors quickly and directly, but for beginners, it's important to constantly cycle through all four windows when you debug. The focus now is on working meticulously to develop good habits, not on being super fast. 'Fast' will come in time.
.
---5 TIPS---
1. Go SLOWLY and METHODICALLY. Understand each line of code.
For some beginners, the faster you try to debug, the longer it will take. Take a break. Be methodical. Go line by line. Pause to understand what each part of the code is doing before moving on. The more methodically you can debug, the faster you will find and fix your errors.
2. Use the fail fast flags in your rspec command in bash.
You want to do everything you can to speed up your feedback loop. The fail fast flags output only the first test that fails obviating the need to scroll through the entire list of failures every time your run rspec:
'rspec --fail-fast'
3. READ the error message CAREFULLY.
You will usually find all the clues to fix your code entirely in the error message. Read every word very carefully. Learn the syntax of the error message. This is super critical to becoming a proficient debugger.
4. Read the spec.
Read the spec alongside the code.
Not only do some errors become apparent only upon reading the spec, sometimes there are errors in the spec that you may need to correct - something that won't be as apparent.
5. Use PRY and bind it to your code.
IRB and PRY are underused by many beginners. They are powerful tools that will greatly speed up the debugging process.
Using these tools to debug can seem daunting, but it's really simple. There are just two things beginners need to do when debugging: copy-paste relevant code into pry/irb to test it directly and create new objects to test methods on the fly.
One way to do this quicker is by having your Ruby code jump immediately into Pry for debugging upon running it. You enable this by requiring Pry in your code and adding 'binding pry' at the very bottom of your code.
.
None of this is hard - even for developers. They're just new habits that may be a bit awkward and uncomfortable at first, but are essential to becoming a proficient, responsible coder.
In an upcoming post, I'll expand on reading error messages with some examples and tips. Until then, cheers!