tdj

In my experience, I have started to believe ML Engineer is short for "YAML Engineer".

I built a similar app using a Kaldi's nnet3 model running embedded; the thing was so responsive that our demo to an SVP went sideways: when he gave a query, the app responded nearly immediately after the sentence ended. The SVP did not realize it already responded, as the expectation for voice interaction systems was that it takes like 2-5 seconds to get an answer, which made the impression that the system did not work properly.

So, moral of the story, if you do a too good job of making a fast speech engine, especially for multi-turn dialogues, add some delays so it resembles human dialogue more.

Both of the titles you mention were the type of books that I had to put them down and started reading them again later. For different reasons though. Once the world building clicked, they really shine.

The building I live in in Berlin, 1910-ish construction with two more wings in the courtyard, everything accessible through the front gate - it has the same principle implemented with a timer and a button. I thought it's a bit odd, but made some sense after a while.

During the day, the front gate can be opened from the outside with just pushing a button that unlocks the door. At night (from 20 or 21 or so), the button stops working, you need the key. It can be opened at any time from the inside without keys. So it's more or less implementing the same protocol, but electro-mechanically, so there is no need for the trick with pulling the key inward.

This screenshot of an Ars Technica journalist with Phil Zimmerman, PGP author (yes, not the same as GPG), is very telling:

https://arstechnica.com/information-technology/2016/12/op-ed...

My beef with Slack is that everyone in this comments section is pretending it's an async communication tool, but that is only true people that are used to working without context switching and acknowledge that interrupting someone has a cost. For everyone else, there is an expectation of prompt responses, or you are considered untrustworthy if you take too long to respond.

I suspect a lot of frustration fundamentally revolves around trust. If there is a lack of trust, it must get compensated with an increase in visibility. Slack just happens to be a decent tool to provide visibility.

Story time: in a company I worked for, the Most Senior Engineer requested to be exempt from participating on Slack as the only person outside management, and skip the daily stand-ups. He did get a lot more done. I envied him quite a bit - mostly because our stumbles and challenges (just normal development stuff) were very visible and prompted lots of nervouse queries from PMs and sales people via Slack about why our tests are failing and why we needed to refactor code, whereas he only needed to show the end result of his work after a few months. Even if we had both experienced the same amount of 'challenges', his way of working gave him a lot more credibility because he got to control the narrative where his solution emerged working as designed (because any development hurdles he may have had were invisible to our PMs and sales). However, he did have a lot of pre-existing trust with key people to pull this off in the first place.

I hope I get to a point in my career where I can operate like that.

Krško is a Westinghouse design. I've spent quite some time in the area, and nobody really worried about the power plant. The smell of the cellulose plant in the city center on the other hand, ...

Their hypercube covering formalism can be seen as decision tree induction with a specific partitioning rule, and terminating branching only at uniformly labeled leaves. But try are using the tree nodes as kind of an embedding to apply a softmax on. I like the connection between relus and the geometrical representation, makes it easier to think about in spatial terms.

Reading this I got several dejavus to my grad school classes on classical ML stuff. I like the direction but it feels like it could be better if it admitted that it's a variant of decision tree embedding, and built on some of the massive amount of research work in that area. At least in terms of understanding.

I suspect doing a random forest version of this would actually help. Perhaps we will see this as a legit pre-training step.

After interacting with a post about yachting, the ad engine behind Instagram suddenty thought I am a multi-millionaire and I got a ton of ads on fancy watches, McLarens, Bentleys, and of course boats. Felt good for a while.

Not sure how many do this, but you're basically describing my situation, 8 min commute to Mitte, and relatively cheap. Due to the rent control, rents only jump after tenants change. An identical flat to mine, below me, was just now online available for rent for about 20% more than my rent is - and got rented out within a month, so there's demand.

I don't think there's a fear for displacement yet, there's quite a few plots to build up, or abandoned places that are torn down (e.g. Stattbad), and a bunch of new modern apt buildings coming up. But for now, it looks like Neukölln is the more desirable next-hip-thing.

One common pattern I had to frequently use was HSET of the same key on multiple hashmaps and different values. Not quite HMSET, but MHSET was a good name for it.

I remember reading about this in the late 90s, open hardware was a fairly new concept then. But you needed to be an electrical engineer to make one yourself, more or less; I wanted to build a pair with a friend so we could play gamed (this was in dialup times). Soon broadband made it obsolete for casual users in urban areas.

There's a modern day equivalent, with up to 10Gbps capability using infrared - http://koruza.net/

Aren't skip-grams equivalent to NMF of the PPMI matrix?

https://papers.nips.cc/paper/5477-neural-word-embedding-as-i....

Actually once you have information on depth (which isbwhat they get from multiple camera perspectives), and your bas image at near-infinite DoF you can pretty much dial your depth of field however you want. Actually your next limit is how accurately you can measure depth, and that is limited by the distances between the individual sensors.. With a longer baseline you could do pretty thin focused slices, and blur the rest.

There was a pretty good interview with their CTO a few months ago on Imaging Resource. Much more technical than what you see on the site, also gives a glimpse on what they were thinking when they were developing this.

http://www.imaging-resource.com/news/2015/04/27/light-interv...

Personally I think the money shot is the synthetic DoF simulation on the skater:

https://light.co/content/2-gallery/gallery_modal_11.jpg https://light.co/content/2-gallery/gallery_modal_06.jpg

The subject isolation properties is a pretty big reason why people still bother with large-sensor cameras. As an amaterur, I don't have big demands for image quality, so I only bring my D60 or F4 when I want subject isolation. Otherwise I'm pretty happy with my smartphone as a camera (Lumia 930).

I'm 29, and I have already started feeling this. Just a few years ago, I could do 12-14h coding days sustainably, but now, anything above 11h sustained for weeks really shows in my output quality. Luckily, my overall productivity is still rising due to learning and experience, despite the degrading mental capabilities. I don't know what me at 35 will look like. I now see where the ageism comes from.

I find it incredibly sad that I even need to think about this. I regret that I even participated in this circus in the first place. I now only work for companies with don't have the ass-in-seats-for-80h policy. It's actually interesting that in startups where this works, people self-select and end up there. It's amazing how much more you can achieve if you can afford to take a step back, and not worry how you can run in circles even farther and faster.

A layout engine works on a different level of abstraction, putting layout features in CSS will be awkward. CSS is fine for typographic features and selectors, but layout is all about relationships.

Actually, one really impressive engine for web layout engine is Treesaver: https://github.com/Treesaver/treesaver

It's meant to provide primitives that are familiar to people from graphic design working on paginated content, like columns, grids, floating containers. Like Latex, it's also has the least-bad-layout strategy, but here, this runs on the client in Javascript, so that it adapts to the screen size.

I had just stopped working on a startup based on this technology. Operationally, it was proving extremely difficult adding effects that people are taking for granted in InDesign to work in a responsive manner on top of CSS and a 20kLoC Javascript layout engine. It took around a year of development just to get to the level of layout automation sophistication comparable to what a junior layout designer would produce.

Does anyone have a good explanation for why the pages uses 1-frame videos for static pictures? Does WebM offer better quality-per-KB than JPEG?

This. I use 0.1px for smaller type, and 0.25 for bigger. It also makes it look thicker.

Also, the same problem is also present in Safari for Windows, in case anyone actually uses it..

I'm pretty happy with django-compressor.

It's a horrible thing indeed, especially when trying to use a print-optimized font. Luckily the canary version uses the fancy Windows font rendering pipeline so it's merely a matter of time.

We ended up applying a text shadow of 0.15px to smooth out the eaten-by-mice effect. It's a bit softer, but a good compromise. Fonts with good hinting seem to work better.

I'm surprise no-one mentioned ALICE - aluminium + ice (water). A paste-like substance that's quite a powerful rocket propellant.

http://news.discovery.com/tech/nanoaluminum-rocket-fuel.html

It would be good to note that this implementation doesn't actually support de-compression (as is also noted in the to-do list).

It is able to read headers and other metadata, as well as unpack files, but only if they're stored without compression: https://github.com/43081j/rar.js/blob/master/dist/rar.js#L54...

If I understand RAR, it actually uses a embedded virtual machine to specify the compression algorithm. That would have been the fun part.

Actually, I think you could save yourself some trouble and use scikit-learn's built-in text preprocessing utils:

Word counter: http://scikit-learn.org/stable/modules/generated/sklearn.fea...

Hashing vectorizer if you want to trade off explainability for speed and scalability: http://scikit-learn.org/stable/modules/generated/sklearn.fea...

TF-IDF weighing: http://scikit-learn.org/stable/modules/generated/sklearn.fea...

Also, if you transform bag-of-words vectors into a dense form, you're gonna have a bad time (insert appropriate meme picture here). In large corpora, dimensionality grows quite substantially - if you work with news corpora or Wikipedia, you're in the 100k-1M dimensional space pretty quickly.

Great to see an approachable explanation for NLP. As they say sometimes, when you know how it's done, it stops being "Artificial Intelligence".

I solved this by using the "Insomniac" approach - if you play a silent sound every 30 seconds or so, the scheduler will reset the sleep timer and the app will keep working. It drains the battery in around 1 day though.

I developed a similar app for a psychology research team. They needed a way to trigger certain things (sound recording, etc) when two certain people were in physical proximity. As it turns out, bluetooth bonjour discovery did the trick when they were in the same room. Over wifi, it got triggered sooner, once one of them enterred the building where the other one was (which corresponded to being on the same LAN).

The hard problem on iOS devices (iPod touch) was keeping them awake during this, so they could detect eac other. iOS likes to sleep while locked. Got a solution, which made the battery last around a day. I guess they're not using mobile to mobile peer triggers, but fixed-to-mobile and then deliver a notification. Interesting to see this popping up in commercial tech.

I was going to spin my code out into a infrastructure for spatial awareness triggers for various home automation tasks, but also couldn't find a killer use case. I'll be following this topic for ideas :)

I strongly recommend Gisgraphy - http://www.gisgraphy.com/ [not affiliated, just a happy user].

They offer both SaaS, as well as a simple way to deploy the whole thing and run a local (reverse-) geocoding server. It does take a few days to build the GeoNames + OpenStreetMap index though. I run it locally for mapping coordinates to cities and it runs quite decently, a 2-core 2GB Linux VM running PostgreSQL gets me about 80-100 queries/s. It has a nice JSON API so it shouldn't be too hard using it from iOS.

I've used both Colt and apache commons math in a machine learning setting. It was mostly the better handling of sparse matrix ops that made apache a couple of times faster than colt (due to hash-based vs. sorted list vectors) It was pretty much the same on dense linear algebra. Intel MKL, eigen, uBlas can be better, but I haven't done the benchmarks to prove this either way.

LLVM is pretty cool. I've started using it in development simply because the compile times are much faster than GCC and the clang error messages actually make sense.

I also wish that this testing methodology would be adopted by other projects, makes QA much easier.