Hurricane Irma

me: why haven't i bought this game yet

me: oh right i forgot i need money to purchase goods and services

*5 minutes pass*

me:

me:

me:

me: why haven't i bought this game yet

Update: The New Yahoo Finance

By Michael La Guardia, Senior Director of Product for Sports & Finance

A couple of weeks ago we introduced the world to our new Yahoo Finance page.  As we told you then, our goal is to provide the same quality content our users have come to expect, with cleaner, more modern designs and a focus on increased personalization and community engagement.

At launch, we asked our users to share their thoughts and feedback, so we can continue to iterate and improve our product.  We heard from many of you, and one thing is certain:  Yahoo Finance inspires deep passion and loyalty. We appreciate how vocal the community has been since the redesign - both with pats on the back, some great suggestions, and some frustrations - and we’ve been listening to all of it.  We’ve contacted many of you directly to let you know we’re addressing these concerns, and we’ve made real progress based on your feedback.   

To date we have closed a number of major issues, and dozens of smaller ones.  Here is a quick list of what’s been done so far:   

We’ve addressed many data availability and quality issues.

We added back options data for the S&P VIX ticker.

We added analyst 1 year price targets to the right side of the Key Stats module.

We’re now live updating all standard quote details on the Quote Summary Page.

We are once again showing “Get Quotes for Top 10 Holdings” link for ETF and MutualFund quotes.

We’ve restored our databases and should now have the same level of historical data that we used to have.  We also made it easier to manipulate date ranges for historical data.

All recent SEC filings are available for tickers again.

We’ve added “Yield” back to tables for bonds.

We have made adjustments to the way the site is laid out and how you interact with it.

You can now copy data out of our Historical Data pages and paste it correctly into a spreadsheet.

We increased the density of the data table on the Statistics tab.

When you navigate from one Quote Summary Page to another, we now keep you on the same tab.  For example, if you were looking at Yahoo’s financials and navigated to the Alibaba Quote page, the new page would open on the Financials tab.

We’ve made many headers clickable for direct access to deeper information.

Clicking on an option strike price now shows all options available at that price.

We restored the link to the Currency Converter tool.

We fixed bugs that you pointed out.

The Recently Viewed list no longer gets wiped out.

You can now select MAX time frame on historical data.

Adding a symbol to multi-quote now no longer wipes out the whole list.

Our products are constantly evolving, and we’ll continue to answer your questions and address your concerns.  There is still more to do, including some exciting new features that will be rolling out in the coming months.  You’ll be hearing from us regularly as it happens.  

In the meantime, keep your suggestions and feedback coming. 

Creativity is not a rare insight, that comes to you suddenly, once in a lifetime, to change the world. It’s just the opposite…The key is to learn how to bring your ideas together, over time.

Keith Sawyer (via creativesomething)

me: damn I hate winter GIVE ME SPRING AND SUMMER

spring starts, bugs start coming out

me: take me back to winter

Be yourself; everyone else is already taken.

Oscar Wilde (via story-dj)

NASA Astronomy Picture of the Day 2016 September 4 

Io over Jupiter from Voyager 1 

Back in 1979, NASA’s Voyager 1 spacecraft flew past Jupiter and its moons. The images in this mosaic, featuring the moon Io against a background of gas giant Jupiter’s diffuse swirling cloud bands, were recorded by Voyager’s camera from a distance of about 8.3 million kilometers. The Io image from this mosaic may be the first to show curious round features on Io’s surface with dark centers and bright rims more than 60 kilometers across. Now known to be volcanic in origin, these features were then thought likely to be impact craters, commonly seen on rocky bodies throughout the Solar System. But as Voyager continued to approach Io, close-up pictures revealed a bizarre world devoid of impact craters, frequently resurfaced by volcanic activity. Earlier this year a new robotic spacecraft, NASA’s Juno, began to orbit Jupiter and last week made a pass within 5,000 kilometers of Jupiter’s clouds. During the next two years, it is hoped that Juno will discover new things about Jupiter, for example what’s in Jupiter’s core.

A software problem which has already been solved, but not everywhere.

In the early days of the WWW, some websites were a lot better than others. Some places you would fill out a form and it would log you out and forget your stuff; the meaning of icons varied across the web; ….

Nowadays, there are a lot of Standards. There’s a certain way things generally work. Visual cues consistently mean the same thing and work the way I, as a semi-daft user with a lisp and a peg leg, would expect it to, without any further thought or research.

How did this wonderful increase in usability and optimisation happen? I think it’s due to JQuery.

For those who don’t know, JQuery is a bunch of software libraries that do common tasks like “initiate twitter-like pagination” or “build a form” the right way. In other words, some people who had seen a lot of good and bad choices, wrote some functions that any other programmer can use, and wrote down all the best 500-line programs so that other people could do them with just 1 line. (If you still don’t understand what I mean by a “library”, look at the third or fourth lesson on an introduction to C++ tutorial – somewhere in the beginning the instructor will explain why sometimes you want to take a long program and split off bits of the code as separate functions.)

  So here are several problems that have all been solved very nicely. The problems were that:

not everyone has the time/funds to perfect every last nanometer of their website

not everyone has the expertise to do everything perfectly

consequently, users had a bad experience

consequently, less business was transacted online

many people were solving the same problem

too much code was being written to solve the same problem in different places

consequently, management’s and programmers’ interests were disaligned.

The problem was solved through specialisation, as well as programming techniques like abstraction, callbacks, encapsulation, so on.

How far can this Library solution be taken? I mean both in the sense of economic viability and in the sense of programmability.

If I’m typing in some random stuff into R, I kind of expect that sparse matrices are multiplying in the best way possible, or in general that calculations are being done as quick as they could be.

Wouldn’t it be nice if every data structure could automatically tap into any relevant mathematical theorems that reduce calculation time or provide insights? For example the computer shouldn’t literally add the numbers 1+2+3+…+97+98+99+100 because mathematicians already know that 1+100 + 2+99 + 3+98 + 4+97 … = 101 × 50, which is way quicker to calculate. Wouldn’t it be great if data structures could automatically “know” (via libraries) any theorem about curvature, graph traversal, Yoneda lemma, and so on, without the programmer having to be a maths textbook him/herself?

Is this impossible? Or has it just not been done yet?

Automating the Publish/Subscribe Pattern in JavaScript

The Publish/Subscribe pattern is one of the most used patterns in software, especially in User Interfaces with JavaScript. It is used whenever 2 pieces of a system need to communicate, but cannot or should not communicate directly. For example, a system receives data from a server at regular intervals that a bunch of components can use (which are added while the system runs):

var Publisher = function() { var self = { subscribers: [] }; self.subscribe = function(callback) { self.subscribers.push(callback); }; self.publish = function(data) { self.subscribers.forEach(function(callback) { callback(data); }); }; return self; } var publisher = Publisher(); // Simulate a set of data being returned over time var serverStream = function(callback) { Array.apply(null, { length: 5 }).forEach(function(unused, index) { var ms = index * 500 setTimeout(function() { callback('data-piece: ' + ms + ' ms'); }, ms); }); }; serverStream(publisher.publish); // Simulate components being registered over time. publisher.subscribe(function(data) { console.info('subscribe from part 1', data); }); setTimeout(function() { publisher.subscribe(function(data) { console.info('subscribe from part 2', data); }); }, 1000) // subscribe from part 1 data-piece: 0 ms // subscribe from part 1 data-piece: 500 ms // subscribe from part 1 data-piece: 1000 ms // subscribe from part 1 data-piece: 1500 ms // subscribe from part 2 data-piece: 1500 ms // subscribe from part 1 data-piece: 2000 ms // subscribe from part 2 data-piece: 2000 ms

The problem is that same pattern with almost identical code will be written over and over again in the same project. So instead of creating a publisher and subscriber with multiple message types each time this pattern needs to be used, it is simpler to just use new instances of the publisher object each time:

var messageSet1 = function(callback) { Array.apply(null, { length: 3 }).forEach(function(unused, index) { setTimeout(function() { callback('Hello ' + index); }, index * 500); }); }; var messageSet2 = function(callback) { Array.apply(null, { length: 3 }).forEach(function(unused, index) { setTimeout(function() { callback('World ' + index); }, index * 500); }); }; var MessageBox = function() { var self = { publishers: [] }; self.streams = function(streams) { self.publishers = []; streams.forEach(function(stream, index) { self.publishers.push(Publisher()); stream(self.publishers[index].publish); }); }; self.subscribeTo = function(index, callback) { return self.publishers[index].subscribe(callback); } return self; }; var messageBox = MessageBox(); // Use a trivial example to preserve clarity messageBox.streams([messageSet1, messageSet2]); messageBox.subscribeTo(0, function(data) { console.info('subscribe from part 1B', data); }); messageBox.subscribeTo(1, function(data) { console.info('subscribe from part 2B', data); }); // subscribe from part 1B Hello 0 // subscribe from part 2B World 0 // subscribe from part 1B Hello 1 // subscribe from part 2B World 1 // subscribe from part 1B Hello 2 // subscribe from part 2B World 2

A non-index based naming scheme could be introduced by passing more data into the streams call, but I wanted to keep the example as minimal as possible.

Github Location: https://github.com/Jacob-Friesen/obscurejs/blob/master/2016/publishSubscribeAutomation.js

Books every programmer should read

Code Complete (2nd edition) by Steve McConnell

The Pragmatic Programmer

Structure and Interpretation of Computer Programs

The C Programming Language by Kernighan and Ritchie

Introduction to Algorithms by Cormen, Leiserson, Rivest & Stein

Design Patterns by the Gang of Four

Refactoring: Improving the Design of Existing Code

The Mythical Man Month

The Art of Computer Programming by Donald Knuth

Compilers: Principles, Techniques and Tools by Alfred V. Aho, Ravi Sethi and Jeffrey D. Ullman

Gödel, Escher, Bach by Douglas Hofstadter

Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin

Effective C++

More Effective C++

CODE by Charles Petzold

Programming Pearls by Jon Bentley

Working Effectively with Legacy Code by Michael C. Feathers

Peopleware by Demarco and Lister

Coders at Work by Peter Seibel

Surely You’re Joking, Mr. Feynman!

Effective Java 2nd edition

Patterns of Enterprise Application Architecture by Martin Fowler

The Little Schemer

The Seasoned Schemer

Why’s (Poignant) Guide to Ruby

The Inmates Are Running The Asylum: Why High Tech Products Drive Us Crazy and How to Restore the Sanity

The Art of Unix Programming

Test-Driven Development: By Example by Kent Beck

Practices of an Agile Developer

Don’t Make Me Think

Agile Software Development, Principles, Patterns, and Practices by Robert C. Martin

Domain Driven Designs by Eric Evans

The Design of Everyday Things by Donald Norman

Modern C++ Design by Andrei Alexandrescu

Best Software Writing I by Joel Spolsky

The Practice of Programming by Kernighan and Pike

Pragmatic Thinking and Learning: Refactor Your Wetware by Andy Hunt

Software Estimation: Demystifying the Black Art by Steve McConnel

The Passionate Programmer (My Job Went To India) by Chad Fowler

Hackers: Heroes of the Computer Revolution

Algorithms + Data Structures = Programs

Writing Solid Code

JavaScript - The Good Parts

Getting Real by 37 Signals

Foundations of Programming by Karl Seguin

Computer Graphics: Principles and Practice in C (2nd Edition)

Thinking in Java by Bruce Eckel

The Elements of Computing Systems

Refactoring to Patterns by Joshua Kerievsky

Modern Operating Systems by Andrew S. Tanenbaum

The Annotated Turing

Things That Make Us Smart by Donald Norman

The Timeless Way of Building by Christopher Alexander

The Deadline: A Novel About Project Management by Tom DeMarco

The C++ Programming Language (3rd edition) by Stroustrup

Patterns of Enterprise Application Architecture

Computer Systems - A Programmer’s Perspective

Agile Principles, Patterns, and Practices in C# by Robert C. Martin

Growing Object-Oriented Software, Guided by Tests

Framework Design Guidelines by Brad Abrams

Object Thinking by Dr. David West

Advanced Programming in the UNIX Environment by W. Richard Stevens

Hackers and Painters: Big Ideas from the Computer Age

The Soul of a New Machine by Tracy Kidder

CLR via C# by Jeffrey Richter

The Timeless Way of Building by Christopher Alexander

Design Patterns in C# by Steve Metsker

Alice in Wonderland by Lewis Carol

Zen and the Art of Motorcycle Maintenance by Robert M. Pirsig

About Face - The Essentials of Interaction Design

Here Comes Everybody: The Power of Organizing Without Organizations by Clay Shirky

The Tao of Programming

Computational Beauty of Nature

Writing Solid Code by Steve Maguire

Philip and Alex’s Guide to Web Publishing

Object-Oriented Analysis and Design with Applications by Grady Booch

Effective Java by Joshua Bloch

Computability by N. J. Cutland

Masterminds of Programming

The Tao Te Ching

The Productive Programmer

The Art of Deception by Kevin Mitnick

The Career Programmer: Guerilla Tactics for an Imperfect World by Christopher Duncan

Paradigms of Artificial Intelligence Programming: Case studies in Common Lisp

Masters of Doom

Pragmatic Unit Testing in C# with NUnit by Andy Hunt and Dave Thomas with Matt Hargett

How To Solve It by George Polya

The Alchemist by Paulo Coelho

Smalltalk-80: The Language and its Implementation

Writing Secure Code (2nd Edition) by Michael Howard

Introduction to Functional Programming by Philip Wadler and Richard Bird

No Bugs! by David Thielen

Rework by Jason Freid and DHH

JUnit in Action

Source: http://stackoverflow.com/questions/1711/what-is-the-single-most-influential-book-every-programmer-should-read

Shoutout to tumblr users without internet friends.

Shoutout to tumblr users who are still trying to figure out aspects of tumblr.

Shoutout to tumblr users who for whatever reason feel excluded from fandoms/other communities.

Shoutout to tumblr users who feel lonely.

Shoutout to tumblr users who feel like everyone else on tumblr is cooler or smarter or better than them.

I’m prayin for us to overcome self-consciousness, shyness, whatever is in our way. You’re not defined by your blog or your online presence. I love you and know you can do anything.