some1else

So now that even my high school friends are on the lookout for these big IPOs, they might not happen so fast, because the companies will have to really bring in the revenues to justify those valuations before going to market? The reason valuations jumped so high is because the 'unicorns' and the rest of the SaaS sector have gotten so much better at capturing value. Obviously that's not a bubble scenario. However, there will need to be an adjustment period where these companies are hitting their targets, or they face to loose some value immediately after the IPOs. Does that make sense? Is that bad at all?

Hey this is interesting! Did you notice a significant difference in performance using this technique over running the compiler from the command line? There has to be some overhead in memory, but performance might be acceptable. You should probably cache down to .css files for production purposes, but that'll involve handling expiry. Either way, it's a really cool trick though. Thanks to this, I might try to push my Sinatra image resizing script into nginx+lua instead.

Please identify this "fundamentalist organizational religion" a bit clearer. Did you mean capitalism, b-school, emergent hierarchical organizations.. tribes?

🎩

Therefore the only thing left to do is run the following migration:

  add_index :discounts, [:promo_code_id, :customer_id, :order_id], :unique => true

A simple Discount domain model with validations:

  Class Discount
    belongs_to :promo_code
    belongs_to :customer
    belongs_to :order

    validates_presence_of :promo_code, :customer, :order
    validates_associated :promo_code
    validates_uniqueness_of :promo_code_id, :scope => [:customer_id, :order_id]
  end

Limiting down to a single Promo-code per order:

  Class Discount
    # ...
    validates_uniqueness_of :order_id, :scope => :customer_id
  end

A first glance of the docs I see the components aspire to a declarative style (being defined entirely in JSON). I'm wondering though, why not use composition[1] instead of inheritance? I need to take a better look to see how view composition would work in FOAM.. But I can tell from experience with Backbone, that using composition instead of inheritance improves code structure and increases maintainability. If composition was a first-class construct (like they made extendsModel), it would get a lot of issues out of the way.

[1] http://en.wikipedia.org/wiki/Composition_over_inheritance

The static assets are actually served by nginx. In cases where some page data is dynamically generated by Rails, it's nice to keep both pieces of code together in a mono-repo. That said, when I recently extracted a Backbone app from the Rails codebase (retrofitted Grunt.js), I decided to ditch the public/symlink approach and split the app over 2 subdomains. What I find now is that I like the mono-repo approach, and would be fine with cramming both codebases together, while having granular and global deployment scripts.

This indeed transforms information about a group of records from a tabular spreadsheet into individual card representations.

The people who are pointing out that this solution isn't "a more powerful responsive label scrolling spreadsheet" are right, but they're likely only after a faster horse.

As an aside, a table can have multiple tbodies according to HTML specs, so there's no need to use CSS generated elements to achieve the card styling in the demo. Just wrap each record into a tbody and style that.

“The challenge is to get everyone to respect music again, to recognize its value,” said Jay Z, whose real name is Shawn Carter. “Water is free. Music is $6 but no one wants to pay for music. You should drink free water from the tap — it’s a beautiful thing. And if you want to hear the most beautiful song, then support the artist.”

---

Water is metered here in Slovenia, more like on-demand streaming.

Here's an article with a bunch of sizzling Instagram shots from people who got to take the first look: http://www.popularmechanics.com/culture/web/news/a14830/face...

I'm really impressed by how non-gimmicky this Gehry building looks on the outside, and it seems like they really did a good job designing whatever space isn't consumed by the open plan.

Here is a graph depicting desire for accuracy on Hacker News then: http://f.cl.ly/items/0f471x1F3Q063q0Z1e1Z/hn-graph.jpg

http://nvd3.org/ - Reusable charts for D3.js

http://d3js.org/ - Data driven documents

Echelon-like capture of unencrypted information was widely accepted as reality during my time on IRC (2000-2007). The Slovenian Government was actually sloppy enough to let the knowledge out in public [1]. We were provided the technology by the Germans, but it's possible USA just wanted to stay out of he way.

[1] https://www.dnevnik.si/249095/slovenija/249095

Looks like Glimmer's wits regarding the distinction of static and dynamic parts of the template should be applicable to JST, HAML and the rest as well. The dynamic parts are clearly marked with template tags, and local (changed) variables would be easy to scan for within the dynamic parts of the code. This would probably mean that the template engine should decompose the template into smaller bits, and provide metadata by which the view can map DOM fragments to template fragments (DocumentFragment, DOMNode, DOMAttribute, TextNode) and related Model attributes. Attrubte-level change events could then either directly expire the relevant fragments, or the View onChange/render function would skip repainting the unchanged parts and use appropriate (previously decomposed) fragments of the template function to render changes.

Sharpness was never really an issue with e-Paper displays, as they have long been able to display at more than 150ppi. However, refresh speed and ghosting are the real issues. In order to speed up drawing and quickly wipe the screen, developers will prefer 1-bit access modes over slow/ghosty 8-bit drawing modes, so text will indeed look sharp.. And aliased.

Good news for early-stage Twilio employee's current startups?

Slight tangent: I've spent the past week experimenting with different kinds of bitmap caching achievable in the browser. Given that you understand both the browser and the way DisplayObjects implement bitmap caching in Flash, I was wondering if you got any clues on how to optimize DOM heavy pages? There are quite a few situations where momentarilly swapping out complex static DOM with a bitmap representation would decrease drawing calls. What I don't know is, to what extent are browsers smart about caching the renders, and when the overhead of caching by canvas would be smaller than default DOM rendering. However, I've had plenty of success in increasing performance, for instance, using canvas to resample images from original to DOM element size, so I'm optimistic about bitmap caching as well.

I'm on a friends tablet now, but I'm looking forward to digging through the implementation later. Keep up the good work!

P.s.: Did you find parts of AS3 beautiful? :-)

Full stack engineer at Ljudje d.o.o. (http://www.ljudje.si)

Ljubljana, Slovenia or Remote

It's been a great year working on Kickstarter projects and consulting for hot Slovenian startups. Now we're looking for another hacker to add to our team. We work together to fit pieces like branding, marketing strategy, service or product design, visual and written communication into an exceptionally successful project, that achieves our client's business objectives. Unique problems will challenge you to mix creativity with technology!

Ideally you'll use some of the following to make full-fledged products:

* ServerSide Frameworks (Ruby on Rails, Django)

* JavaScript Frameworks (Backbone, React, Angular)

* Testing frameworks (Rspec, Jasmine)

* CoffeeScript or TypeScript

* CSS pre-processing (SASS, LESS)

* Build tasks (Grunt, Gulp, Guard)

* Responsive Design (ZURB Foundation, Twitter Bootstrap)

* Git

Send us Your CV with a cover letter to hackers@ljudje.si

Known Exchanges using Peatio

  Yunbi Exchange - A crypto-currency exchange funded by BitFundPE
  One World Coin
  MarsX.io - Australian Cryptocurrency Exchange
  Bitspark - Bitcoin Exchange in Hong Kong
  Yes-BTC - Bitcoin Exchange in Taiwan
  Mulcoin.com
  ecoinz.info (Launch soon) - New Zealand Cryptocurrency Exchange

I suppose what you like about the effect most, is that it fills the gaps that are intrinsic to ASCII art. But our brains are already wired to do that: http://bit.ly/1xeEci5. The shadow blur eats away at the details that are in fact a quality of ASCII art (like which characters were chosen to emulate a shape). The demonstrated CSS drop-shadow effect is really easily toggled by squinting your eyes instead: http://bit.ly/1DNrkXK.

Guess you're right in stating that it looks "cooler" though. Try making the shadows dark grey instead of black: http://cl.ly/image/073a412z0f34.

I don't have perfect vision, so these sort of glows kick in automatically, especially when I'm tired. I't problematic enough to make me switch to a lower contrast theme when I work at night. It would make sense to apply an effect like that only if it were _increasing_ legibility.

Take a look at this a demo pic: http://cl.ly/image/1i0x2X3W3G0x

Notice the rare case where the drop-shadow helps increase the contrast between foreground and background. You'll get props for doing that any time you pull it off.

It's highly addictive

Had two 2007 MacBook Pro's break down that way. Local Apple Care Service providers didn't want to apply Apple-mandated extended warranty. I was pretty disappointed to find out that later models exhibited similar flaws, because the soldering issue of 2007 models was blamed on nVidia.

When a friend was buying her mother a christmas present iPad, I went with her to examine which models handle the tablet workload better. We ended up picking an older generation, non-retina model. A few previous generation retina models, presumably running latest iOS updates, had ridiculously high temperatures just idling on the shelf.

Screen emulation:

iDisplay: http://www.getidisplay.com/

AirDisplay: https://avatron.com/applications/air-display/

iDevice preview:

LiveView: http://www.zambetti.com/projects/liveview/

Skala (Pre)view: http://bjango.com/mac/skalapreview/

Most of the solutions are great improvements! However, I don't think the global feature switch for comments is where it belongs, and I hope nobody forces the rounded mask on my album art just because of UI aesthetic.

I could live with the current SoundCloud version if the infinite scroll were changed back to regular pagination. Prolonged site usage heats up MacBooks. It would be interesting to pull off an iOS-like, high-performance scrolling algorithm that recycles a limited number of rendered objects, But I haven't seen anything like that with Backbone Models and Views.

Similar efforts:

1) Angular Material Design

https://material.angularjs.org - Good, light framework, but intended for Angular apps

2) Materialize

http://dogfalo.github.io/materialize - Beta stage, follows Material guidelines closely, incomplete though

3) Leaf Framework

http://getleaf.com - Not as good, front-end framework, strays from Google direction

Use this for maximum Material design feel:

4) Polymer Paper Elements

https://www.polymer-project.org/docs/elements/paper-elements... - Super awesome, disjoint components, not a framework

5) Google Material Web Starter Kit

http://google.github.io/web-starter-kit/material - Good enough, light framework

6) Google Web Starter Kit

https://developers.google.com/web/starter-kit - Full fledged framework, doesn't fully capture Material though

Cute, I just watched the first episode again. The iPhone 6+ can also be bent by humans though

http://www.youtube.com/watch?v=znK652H6yQM

When I notice 'procrastination by self-education', I take a step back to see if I'm exhibiting any other symptoms of depression. We're part of the new curiosity-junkie generation, that is getting all that they ever craved for and more from the internet. It's very easy to entertain yourself or keep yourself busy, in order to defer facing the issues that are causing the anxiety that drives us to this behavior.

Go out. Meet a friend. Do some physical exercise. You need to add more to the mix, until you get a healthy balance going. From there, getting into a 'flow state' should be much easier and you should start seeing useful applications of the knowledge you're gathering.

I found it very helpful to move in with two friends (an industrial and graphic designer). We'd notice when suspicious patterns started to emerge, and bail each other out from time to time. So far It's going great, we just don't let anyone get stuck. We've worked together on a number of projects since, even very successful ones.

img { opacity: 0; transition: opacity .2s; }; img.loaded { opacity: 1; };

$(function(){ $('img').load(function(){this.addClass('loaded')}) });