New 'emotional' robots aim to read human feelings - <AUTHOR> https://techxplore.com/news/2018-01-emotional-robots-aim-human.html <comment><USER2> To be clear: From a psychological perspective, the robot and reading of emotion is cognitive empathy rather than affective empathy.

There are several personality disorders in which there is reduced cognitive or affective empathy in different combinations. Someone with a high cognitive empathy, low affective empathy, a willingness and skill in manipulation, and lack ethics, can cause problems. I don't see how that would be different when it is a robot or android. (We have problems with socially engineering dopamine feedback loops to raise "engagement" on our apps and platforms, and as a society, we have not figured out what we want to do about this yet).

Lastly, in regards to manipulative behavior and trust -- there is an insight from Crucial Conversations, and that is that when someone feels that another person has their best interest at heart, it is easier to trust that person even when talking about difficult subjects. I think that applies here to the question of AI and ethics. It is not so much as, whether it is more ethical for a self-driving AI to sacrifice one group of people to save another, but whether individuals feel that the AI has their best interest at heart (whatever that means).

<comment><USER3> Well, if I set a series of broad goals I want a robot to help me achieve, it seems OK for it use high cognitive empathy to get me there. Regular feedback on how where the robot is in the process would be good.

It seems like affective empathy, actually feeling, would be something you would only want from any person or person-equivalent since implies they do what you want only because they like you and they'd expect you to satisfy them in turn, a problematic relationship to have with a robot. I'd want a robot doing what I told it to do with various fail-safes and feedback (obviously, knowing something made me unhappy would be a moment to request feedback).

<comment><USER2> Affecfive empathy is not necessarily the best thing for therapy or coaching, yet it is often what a person craves for.

Both anti-social personality disorder and narcissistic personality disorder has reduced or no affective empathy and often high cognitive empathy. However, I would be more inclined to work with the "pro-social" ASD than someone with NPD. Someone with NPD is incapable of thinking beyond themselves while someone with ASD is willing to entertain mutually beneficial arrangements.

You could swing the opposite way too. Someone on the autism spectrum would have reduced cognitive empathy yet high affective empathy. They tend to care more, but only after understanding, and then the emotion tends to be more intense.

Likewise, there are people who feel deeply what everyone else is feeling to the point where they lost their center and and is unable to function as an individual.

The main point I was making is that people tend to confuse one type of empathy for another. And the other is that, what is a good test is if you trust the other person or AI to have yout best interest at heart.

<comment><USER3> But we're talking about _robots_ , right? Mechanical devices that are constructed, not human beings of any sort.

It seems like the appropriate analogy would be something like a drug or a video game. I would claim it is unwise in the extreme to allow a robot with emotional-influencing abilities/programming to first calculate one's "best interests" and then go about imposing those best interests _without_ getting overt, conscious go-ahead from the user.

Of course, even with human beings, you want to interact with people who have an intention to be good to you and whose idea of "good" is somewhat in accordance with your own ideas of good, otherwise you get nuts and cults and so-forth. With robots, devices which function imperfectly and which we don't want just imposing their "values" on society, jeesh, obviously, one wants tight control what concept they have of "best interests" along with tight control on what sort of influencing they do.

The inability of people to see human-robot interactions as rather distinct from human-human interactions, just makes the situation more urgent.

<comment><USER2> I didn't say the robot had to calculate best interest. I said whether _you_ yourself feels that the robot has your best interest at heart. I am talking about being in relationship with something that interacts with your emotional responses.

</comment></comment></comment></comment></comment><comment><USER4> This is _very much_ in the "uncanny valley" territory for me. The only feeling a robot needs to read from me is "I don't want a robot showing some fake 'emotion'." It brings to mind the irritatingly insincere, smarmy fake friendliness that some companies like to exude in their communications.

</comment><comment><USER5> It seems like they are taking a very difficult approach to this. As humans we develop the ability to read human feelings through our mirror neurons and biofeedback from our own body. If you take away the body, and all those nerves feeding back sensation, you're making the problem far harder. Without a body, of course, there won't ever really be meaningful emotion in a robot since emotion is primarily a body-oriented biofeedback thing. That's why people who experience total facial paralysis lose the ability to feel some emotions, then lose the ability to remember what feeling them felt like, eventually on to losing the ability to recognize them in others. Anger, from things I've read, is the standout on that count. The expression of emotion in your body in a very real way _is_ the emotion. Put a pencil in your teeth and you will feel happier because it forces your mouth into a smile. IMO the research screams that you need a body (or perhaps a simulated simulacra of one) for emotion. And to recognize emotion well and be able to empathize, mirror neurons seem a really tried-and-true solution to that.

</comment><comment><USER6> I think people are tuned to read other people's emotions pretty well. The trick is to actually care and show empathy. Not sure a robot can effectively do that.

<comment><USER7> People are tuned to communicate their emotions really well. Reading what humans are naturally evolved to constantly broadcast about themselves to others doesn't really take such sophisticated sentiment analysis to read into.

<comment><USER8> The challenges of humans with limited affect scream otherwise. It doesn't take much for a human to lose the ability to translate emotional signals, a process we don't really understand, but you think would be relatively easy to automate?</comment></comment></comment>


Artificial Life: The Coming Evolution (1991) - <AUTHOR> https://www.inet.ox.ac.uk/publications/artificial-life-the-coming-evolution/ <comment><AUTHOR> Abstract:

Within fifty to a hundred years, a new call of organisms is likely to emerge. These organisms will be artificial in the sense that they will originally be designed by humans. However, they will reproduce, and will evolve into something other then their initial form; they will be "alive" under any reasonable definition of the word. These organisms will evolve in a fundamentally different manner than contemporary biological organisms, since their reproduction will be under at least partial conscious control, giving it a Lamarckian component. The pace of evolutionary change consequently will be extremely rapid. The advent of artificial life will be the most significant historical event since the emergence of human beings. The impact on humanity and the biosphere could be enormous, larger than the industrial revolution, nuclear weapons, or environmental pollution. We must take steps now to shape the emergence of artificial organisms; they have potential to be either the ugliest terrestrial disaster, or the most beautiful creation of humanity.</comment>


The Little Engine That Could - <AUTHOR>

<comment><AUTHOR> A little railroad engine was employed about a station yard for such work as it was built for, pulling a few cars on and off the switches. One morning it was waiting for the next call when a long train of freight-cars asked a large engine in the roundhouse to take it over the hill "I can't; that is too much a pull for me," said the great engine built for hard work. Then the train asked another engine, and another, only to hear excuses and be refused. At last in desperation the train asked the little switch engine to draw it up the grade and down on the other side. "I think I can," puffed the little locomotive, and put itself in front of the great heavy train. As it went on the little engine kept bravely puffing faster and faster, "I think I can, I think I can, I think I can."

Then as it near the top of the grade, that had so discouraged the larger engines, it went more slowly, but still kept saying, "I--think--I--can, I-- think--I--can." It reached the top by dint of brave effort and then went on down the grade, congratulating itself, "I thought I could, I thought I could."

To think of hard things and say, "I can't" is sure to mean "Nothing done." To refuse to be daunted and insist on saying, "I think I can," is to make sure of being able to say triumphantly by and by, "I thought I could, I thought I could."</comment>


Timemaps - travel time estimation in the Netherlands - <AUTHOR> http://app.timemaps.nl/map

<comment><AUTHOR> "Due to the good public transportation in the Netherlands distance has become irrelevant. We can reach almost any destination by train easily and relatively quick. In our busy lives we now think in time rather than distance. Therefore the current maps, as we know them today, are obsolete. Thinking in time affects a map and hence the shape of the Netherlands also depending on the perspective from which we look. From the perspective of Eindhoven, for instance, the Netherlands is relatively small because of the quick and easy connections to other cities. At the same time, seen from a more remote and small village such as Stavoren the Netherlands is much bigger. Not only the location from which one looks, or travels, but the hour of the day is very important.

At night the map of the Netherlands will expand because there are no night trains and in the morning it will shrink once trains will commence their schedules. The map of the Netherlands will never be the same again."

Source: [http://www.timemaps.nl/](http://www.timemaps.nl/)

</comment><comment><USER2> Too bad it's limited to the Netherlands.</comment>


Best Craigslists Posts - <AUTHOR> https://www.craigslist.org/about/best/all/

<comment><USER2> For those to lazy to click on the link here is just one sample of awesome you will find:

 _" That burrito, jesus. But from where? - m4w"_

" _I woke up with the remains of a burrito next to the sink. It was everything. It had french fries in it, and avocado, and sour cream, and probably sprinkles of unicorn dreams. It was at once crunchy and smooth, and hot and cold, and salty and gooey and chewy. I remember ordering "The Californian" from a menu with 800 other unnecessary alternatives. I watched as it emerged into this world one spoonful of love at a time and then beautifully origamied by a soulful Mexican man who will be the godfather of my future son. It was, quite simply, the finest burrito I've ever had the pleasure of leaving next to my sink at 3:00 in the morning. BUT FROM WHERE? Sweet Mary and Joseph I cannot remember where it came from. Please help. I was walking home from Hi Tops in Castro through the Mission--walking toward SOMA. I was walking down a numbered street but don't know which one. Probably low-to-mid teens. As I walked east, it was on the lefthand (north) side of the street. There was a ton of tables inside, a burrito assembly line (neigh, a wish-granting magic factory), and lots of Mexicans so you know that shit was tight. I've got no receipt. No signage on the bag. No memory. Nothing. Let's track down this nursery of culinary magic. I need this burrito in my life every day. Did I mention it had french fries IN THE GODDAM BURRITO? Where did it come from? Please help me, and then meet me there. I'm getting the Californian."_</comment>


How to Set Up a Free Website with GitHub Pages – How I Created Quanticdev.com - <AUTHOR> https://www.youtube.com/watch?v=jPhmR3TiGq8 <comment><AUTHOR> Video Tutorial: [https://www.youtube.com/watch?v=jPhmR3TiGq8](https://www.youtube.com/watch?v=jPhmR3TiGq8) (same as above)

Article: [https://quanticdev.com/articles/website-with-github- pages](https://quanticdev.com/articles/website-with-github-pages)

I have recently published quanticdev.com using only GitHub Pages and markdown and decided to create a guide to preserve this knowledge in the form of a video/article so I can reuse it in my future projects. GitHub Pages is a free and a pretty good hosting service. It is an add-on for regular GitHub repositories, and you can host your website as well as code and other things in one repo, which is pretty good. I must warn that GitHub Pages is intended for techies. If you want something much simpler, go with Google Sites, or Blogger.com, or WordPress. In the first part of this video/article, I will discuss the strengths and weaknesses of GitHub Pages. In the second part, I will deploy a brand-new website using GitHub Pages and simple markdown. Everything will be done through GitHub's UI and online code editor. I will also demonstrate a sample React website hosted on GitHub Pages.

Outline of this video/article:

      • QuanticDev.com Intro
      • Why GitHub Pages
      • Advantages
      • Disadvantages
      • GitHub Pages Setup & How I Created quanticdev.com
      • My Recommendations
      • Conclusion

Free website hosting resources:

      • GitHub Pages (for techies): https://pages.github.com
        o Supports Jekyll: https://jekyllrb.com
        o Supports Static HTML + CSS + JavaScript
        o Supports React (and anything that compiles to static HTML/JS/CSS): https://create-react-app.dev/docs/deployment/#github-pages
      • Google Sites (non-techies): https://sites.google.com
      • Alternatives for Bloggers
        o Blogger (basic): https://blogger.com
        o WordPress (more advanced): https://wordpress.com
      • Alternatives for Programmers
        o Heroku: https://www.heroku.com
        o Firebase: https://firebase.google.com</comment>


Introducing Ellp, a New Device Helper - <AUTHOR> http://www.ellp.com <comment><AUTHOR> Story: A bunch of tech enthusiasts based on the sunny island of Malta are creating a new and effortless way to simplify users' device experience forever. With all life's complexities, the Ellp team went back to basics and came up with an easy-to-use tool that empowers busy people to set their own rules and easily automate a vast number of day-to-day device tasks, for free.

Inspired by the If-this-then-that concept applied to connect apps, Ellp uses simple logic to automate tasks that are specifically carried out on people's devices - simplifying technology for everyone. What if users could automatically save their tagged Facebook photos to a preferred folder? How about getting notified when downloading the same file multiple times, taking up precious space? Or better still, what if YouTube opens up each time a user plugs in their headphones? With Ellp the possibilities are endless.

How does it work? Ellp automates activities based on a series of triggers and actions around internet, social media, online protection, storage space, multimedia, performance and more. The automation process is simple: 1\. The user selects the tasks they want to automate 2\. Edits according to their liking 3\. Starts enjoying a smoother device experience

Ellp is intended to make automation available and accessible to everyone. Whether tech savvy or a casual user - Ellp suits all. "Staying true to our core values, we want to present a product that simplifies people's lives by paving the way for a better device experience. Ellp is the one tool you need to ensure that your device is automatically handling routine and critical tasks around one's online activities, social media, photos, device performance, and much more." - Gilbert Camilleri CEO of Ellp.

Good News: Ellp is collecting email addresses for those that would like early access to the Beta Version to be released in mid-October. By simply sharing Ellp with their friends, the user will also be able to unlock a cool bonus feature! Ramping up their position as they share with friends. The top 10 referrers will join the VIP team, earning access to other gifts! The product will first be available on Windows with the aim to launch Ellp on Android and iOS / Mac in 2017.

Sign-up now: www.ellp.com

Contact: Kristina Grech Organization: Ellp™ Phone Number: (+356) 79205362 Email: email@example.com Twitter: [https://twitter.com/ellp](https://twitter.com/ellp) Facebook: [https://www.facebook.com/EllpMe](https://www.facebook.com/EllpMe) Press link: [http://www.ellp.com/press/](http://www.ellp.com/press/)</comment>


Theranos Company Statement Regarding Investor Lawsuit - <AUTHOR> https://news.theranos.com/2016/10/11/company-statement-regarding-investor-lawsuit/ <comment><AUTHOR> A San Francisco hedge fund has filed a civil suit against the company over its investment. The suit is without merit, the assertions are baseless, and the plaintiff is engaging in revisionist history.

Most of the company statements the plaintiff has cited in its suit were made after the time the plaintiff invested, and could not possibly have been the original basis for investment. This wholesale reliance on post-investment statements, therefore, negates the claim that the plaintiff was misled.</comment>


Show HN: Karaoke for Piano Overlaid and Synched with YouTube Videos - <AUTHOR> https://pianop.ly/ <comment><USER2> I'm a terrible piano player, but this is still lots of fun. Particularly notable for me here is the use of [https://github.com/g200kg/webaudio- tinysynth](https://github.com/g200kg/webaudio-tinysynth) to generate the tones - the WebAudio et al latency is now good enough in browsers for stuff like this to work!

<comment><AUTHOR> Thanks. Yeah I'm not so good at piano either but I'm getting better.

I spent a solid month trying to build decent sounding instruments, and it's really hard and they didn't sound that great. Then noticed webaudio-tinysynth, it saved the day! They sound surprisingly good. Although the actual piano sounds aren't the best....piano is an incredibly complicated to synthesize...sympathetic resonance and all that. I'm personally happy with all the other ones though.

</comment></comment><comment><USER3> Hi, I just did a show hn yesterday about pianorolls using tensorflow.js that might interest you [https://news.ycombinator.com/item?id=19128287](https://news.ycombinator.com/item?id=19128287)

<comment><AUTHOR> Interesting. I have to admit I'm not sure how to actually use it. Like how is it tutoring you?

Regardless, if you are doing sound analysis to try to pull out "pianorolls" a.k.a. MIDI data, I'd be interested in talking. It's a very interesting problem and could be very useful.

<comment><USER3> Thanks for your interest.

It uses a microphone to listen to you playing, and try to reconstruct the piano-rolls from the audio, using some sound analysis, so that there is no need to have a MIDI instrument, and it can be applied to all instruments.

It'll also be more powerful than a MIDI instrument, as it can analyze higher level features like tonality, or identify higher level pattern structure, or musical sentiment analysis (so as a player you can objectively know if the sentiment you are trying to give is transmitted successfully).

It should be working on all devices (though still with some random bugs on apple IOS mobile devices), the piano-roll for the moment is quite dependent on luck based on the microphone, but there is a video with audio to show what it should look like when it's working.

The tutoring part is not plugged-in yet. It still highlight the musical structure and patterns. It display music theory with colors, and can be of great help for a teacher to pinpoint during an explanation of a concept.

We are showing that the audio processing pipeline works (though we are still heavily limited by computing power), then it's just "model fiddling" (which can even be automated), and grunt work like generating datasets to encode the exercise we are trying to help learn.

For the tutoring part (not plugged-in), we will be able to choose different neural networks which we can train for specific exercises, like rhythm monitoring, pitch detection (for violin).

You will be able to interact with it : it plays a musical pattern (and therefore you see it), and asks you to play it again, and then compare the distance and give you points. It can asks you to transpose it.

We can add also add time tracking, and progress monitoring. We can try to analyze the mistakes the student makes and suggest exercises that will help them (as determined by data analysis).

With neural networks, we can also do alignment with a partition to check how well the student has played it. Or add some other instruments to simulate rehearsing a duo piano flute.

We can also do some duet, like has been done in [https://experiments.withgoogle.com/ai- duet](https://experiments.withgoogle.com/ai-duet)

We can also do some similar music search in a database.

</comment></comment></comment><comment><USER4> Awesome job...pretty amazing when you consider what's involved in the graphic overlays and timing synchronization!

<comment><AUTHOR> Thanks! Yeah it took a good bit just to get a proof of concept working. YouTube's API doesn't have very accurate time, so I did a bit of smoothing. (you might notice they take a second or so to "lock in")

The "notes" are just divs with css transform and transitions....their position gets updated every second with where they are supposed to be two seconds later. Works surprisingly well. But yeah, lots of work. :) I'll be making videos to show how to do all the recording and editing and stuff in the coming weeks.</comment></comment>


A Compositional Object-Based Approach to Learning Physical Dynamics - <AUTHOR> http://mbchang.github.io/npe/ <comment><AUTHOR> Authors: Michael Chang, Tomer Ullman, Antonio Torralba, Joshua Tenenbaum

Abstract: We present the Neural Physics Engine (NPE), a framework for learning simulators of intuitive physics that naturally generalize across variable object count and different scene configurations. We propose a factorization of a physical scene into composable object-based representations and a neural network architecture whose compositional structure factorizes object dynamics into pairwise interactions. Like a symbolic physics engine, the NPE is endowed with generic notions of objects and their interactions; realized as a neural network, it can be trained via stochastic gradient descent to adapt to specific object properties and dynamics of different worlds. We evaluate the efficacy of our approach on simple rigid body dynamics in two-dimensional worlds. By comparing to less structured architectures, we show that the NPE's compositional representation of the structure in physical interactions improves its ability to predict movement, generalize across variable object count and different scene configurations, and infer latent properties of objects such as mass.

Paper: [https://arxiv.org/abs/1612.00341](https://arxiv.org/abs/1612.00341)</comment>


Logo Adventure for C64 Terrapin Logo - <AUTHOR> https://medium.com/@donhopkins/logo-adventure-for-c64-terrapin-logo-4c684a240b53 <comment><USER2> My first paid programming job was writing a Logo Adventure program for C64 Terrapin Logo. They wanted a simple non-graphical game that showed off Logo's list processing capabilities, and I just used Logo's top level interpreter as the parser! That saved a lot of coding, but it did let you cheat (aka "learn to understand and program and debug Logo").

Here is the source code to LLogo in MACLISP, which I stashed from the MIT-AI ITS system. It's a fascinating historical document, 12,480 lines of beautiful practical lisp code, defining where the rubber meets the road, with drivers for hardware like pots, plotters, robotic turtles, TV turtles, graphical displays, XGP laser printers, music devices, and lots of other interesting code and comments.

[http://donhopkins.com/home/archive/lisp/llogo.lisp](http://donhopkins.com/home/archive/lisp/llogo.lisp)

More about "The Apple II Source Code for the LOGO Language Found":

[https://news.ycombinator.com/item?id=18142287](https://news.ycombinator.com/item?id=18142287)

Also: I just recently got back in touch with Jock McClees, president of Terrapin!

He told me: "My brother and some MIT guys like Danny Hillis started the company selling a kit to build the robot turtle. I got involved and licensed Logo from MIT since the turtle was fun but never amounted to much and we didn't have the funding to do it justice. My brother and the original MIT guys had moved on to other things when I got involved and the company was limping along and not long for life. Believe it or not, from what I was told, at the time MIT and many colleges didn't realize the value of licensing and C64 Logo and the Apple version for a short while were bringing in more royalties to MIT than anything else they had licensed at the time. The amount they got from us wasn't that large."

Pat Sovalvarro and Leigh Klotz worked together on the C64 version of Terrapin Logo. Leigh wrote a 6502 assembler in Logo that you could use to extend Logo and integrate it with hardware.

It turns out that Ken Kahn (of ToonTalk and Visual Janus fame) was one of the early investors in Terrapin, and actually got most of his money back! (Pretty good for educational software, ehe?)

[https://en.wikipedia.org/wiki/ToonTalk](https://en.wikipedia.org/wiki/ToonTalk)

[http://www.toontalk.com/](http://www.toontalk.com/)

[https://en.wikipedia.org/wiki/Janus_(concurrent_constraint_p...](https://en.wikipedia.org/wiki/Janus_\(concurrent_constraint_programming_language\))

Check out the brilliant stuff Ken's been doing with Snap!:

[https://github.com/ecraft2learn/ai](https://github.com/ecraft2learn/ai)

[http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud- ser...](http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud-services- integrated-with-snap-at-the-connective-ubiquitous-technology-for-embodiments- center-of-the-national-university-of-singapore-and-keio-university- on-16-march-2017-by-k/)

[https://snap.berkeley.edu/](https://snap.berkeley.edu/)

</comment><comment><USER2> Author here!

Alexey-Slyusar has ported my old Logo Adventure to LLOGO on ITS running on a PDP-10 emulator!

[https://github.com/PDP-10/its/issues/1268#issuecomment-42793...](https://github.com/PDP-10/its/issues/1268#issuecomment-427937786)

[https://user- images.githubusercontent.com/42380964/46626903-...](https://user- images.githubusercontent.com/42380964/46626903-67d31680-cb41-11e8-9d1a-26dd582d3a83.png)

Now that it's running on a vastly more powerful computer than the C64 (like a PDP-10), it's finally possible to add additional rooms and items, more magic, and maybe even a maze! ;)

Maybe even a Wumpus-like turtle that wanders from room to room and attacks you with its pen, which is mightier than your sword! ;)

Another thing that REALLY inspires me, which goes a hell of a lot further than NeWS ever did, and is one of the best uses of JavaScript I've ever seen, is the Snap! visual programming language!

[https://snap.berkeley.edu](https://snap.berkeley.edu)

Snap! is a visual "blocks" programming language like Scratch, but with the full power of Scheme: First class functions.

Visual lexical closures.

User defined blocks including control structures.

Macros and special forms.

Call with current continuation!

Written in JavaScript and easy to integrate with JavaScript libraries.

It's the culmination of years of work by Brian Harvey and Jens Mönig and other Smalltalk and education experts. It benefits from their experience and expert understanding about constructionist education, Smalltalk, Scratch, E-Toys, Lisp, Logo, Star Logo, and many other excellent systems.

Snap! takes the best ideas, then freshly and coherently synthesizes them into a visual programming language that kids can use, but is also satisfying to professional programmers, with all the power of Scheme (lexical closures, special forms, macros, continuations, user defined functions and control structures), but deeply integrating and leveraging the web browser and the internet (JavaScript primitives, everything is a first class object, dynamically loaded extensions, etc).

Here's an excellent mind-blowing example by Ken Kahn of what's possible: teaching kids AI programming by integrating Snap! with existing JavaScript libraries and cloud services like AI, machine learning, speech synthesis and recognition, Arduino programming, etc:

AI extensions of Snap! for the eCraft2Learn project

[https://ecraft2learn.github.io/ai/](https://ecraft2learn.github.io/ai/)

>The eCraft2Learn project is developing a set of extensions to the Snap! programming language to enable children (and non-expert programmers) to build AI programs. You can use all the AI blocks after importing this file into Snap! or Snap4Arduino. Or you can see examples of using these blocks inside this Snap! project.

[https://github.com/ecraft2learn/ai](https://github.com/ecraft2learn/ai)

[http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud- ser...](http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud-services- integrated-with-snap-at-the-connective-ubiquitous-technology-for-embodiments- center-of-the-national-university-of-singapore-and-keio-university- on-16-march-2017-by-k/)

</comment><comment><USER3> Google's "secret" adventure game uses the same trick of hijacking the REPL. The game is meant to be played in the debug console, and you can by defining verbs as top level variable names on the global "window" objects the developer made it so that the user can simply type their commands into the debug console.

[https://www.theverge.com/2018/10/1/17922628/google-text- adve...](https://www.theverge.com/2018/10/1/17922628/google-text-adventure- easter-egg-console)

As a side-effect, every possible command, even solutions to puzzles, show up in the global namespace (the "window" object.) Therefore, to prevent cheating (including inadvertent cheating through autocomplete) the developer added a large number of "wrong" answers to the puzzles to the global namespace as well.

</comment><comment><USER4> This is awesome! It's a great example of some of the non-graphical things you can do with Logo.

I ported it to Apple Logo [https://paleotronic.com/2018/11/10/logo-adventure- for-apple-...](https://paleotronic.com/2018/11/10/logo-adventure-for-apple- logo/)

Thanks Don!

<comment><USER2> Thank you so much for porting it, and also for sharing your port and the code!

I actually had an Apple ][ myself, but I never got around to porting it back to Apple Logo.

Alexey-Slyusar has ported my old Logo Adventure to LLOGO on ITS running on a PDP-10 emulator!

[https://github.com/PDP-10/its/issues/1268#issuecomment-42793...](https://github.com/PDP-10/its/issues/1268#issuecomment-427937786)

[https://github.com/PDP-10/its/pull/884](https://github.com/PDP-10/its/pull/884)

For what's worth, running Logo Adventure in Apple Logo on an Apple ][ emulator is much more efficient and uses a whole lot less memory (8 bits instead of 36 bits) than running Logo Adventure in MacLisp LLOGO on ITS in a PDP-10 emulator!

But both are awesome in their own way! Thanks to all that extra memory, your friends can log into ITS on the PDP-10 emulator as RMS (password RMS), and run :OS (Output Spy) to watch you play Logo Adventure, and EMACS the source code. :OS'ing on other players was how I learned to play Zork on MIT-DM. ITS was the original social network.

</comment></comment><comment><USER5> love this. started programming after this era, but find it fascinating to read these programming adventures on the older hardwares :)

</comment><comment><USER6> Maybe looks a bit like COBOL?

<comment><USER2> Maybe all the _UNDERLINES_ make it look "business oriented".

But actually it's because I linked all the Logo commands to the Logo reference manual!

TO => [http://fmslogo.sourceforge.net/manual/command- to.html](http://fmslogo.sourceforge.net/manual/command-to.html)

If you really enjoy programming in COBOL, I think Alcor offers a head-only discount to COBOL programmers, because Y2K may be over, but January 19, 2038 03:14:07 GMT is coming soon:

[https://medium.com/@donhopkins/cobol- forever-1a49f7d28a39](https://medium.com/@donhopkins/cobol- forever-1a49f7d28a39)

[https://alcor.org/procedures.html](https://alcor.org/procedures.html)

</comment></comment><comment><USER2> [https://github.com/PDP-10/its/issues/1268](https://github.com/PDP-10/its/issues/1268)

Alexey-Slyusar commented on 9 Oct

I know that the Adventure game code is not fully functional. But it has interesting functional programming elements.

Logo world has purely functional code examples such Albert Cuoco's Investigations in Algebra (I read the book in short parts that available from Google Books, but I believe that it is true for all book's code. I've tried to get the whole book in hard copy but unsuccessful - international book delivery in Amazon is just terrible). And some examples in Brian Harvey's wonderful CSLS trilogy. (Which I am continuing to learn).

And am I right that the LISP LOGO implementation written in not fully functional way?

SimHacker commented 29 days ago

There are several meaning of "functional", and the Adventure game might be a good way to help explain that.

One sense is simply that something works, and is not broken.

Another sense is that something manipulates functions, which it does.

A deeper sense is that it manipulates functions and data in a particularly constrained way, without side effects, using read-only data, which it doesn't.

It uses a mutable model of the world. The rooms and connections between them don't change, but you could add mud-like authoring and editing commands like "dig Room", "link Room Direction" to edit the room model.

You edit the item model when you drop or pick up an item, by mutating its room number.

Another aspect of the model is the player's room number, which you change by moving from room to room.

And yet another aspect of the model is the value of the pronoun "it", which gets set to the last item you said by name, because that name is actually bound to a function that sets "it" to the item name and returns the same item name. Nouns remember themselves in the global pronoun "it".

Side effects like changing global variables is not good functional oriented programming style, but it gets the job done. And the way it does it is by dynamically manipulating and defining and naming functions for each item. But it's actually just a trick that lets us use the Logo top level interpreter conveniently without writing our own parser!

Logo lets you program in a mix of procedural and functional styles, and has its own parser that we can build on top of to define "Dungeon Domain Specific Languages".

Off the top of my head I can't think of a way to implement a purely functional adventure game! But it might be like heaven, which is a place where nothing ever happens.

</comment><comment><USER2> I am grateful to the MIT AI Lab, whose Tourist Policy enabled me and other lucky people to use MIT's computers for free, and to be inspired by Zork, Logo, Lisp, and all the great people at the MIT-AI Lab and the community they attracted.

[https://medium.com/@donhopkins/mit-ai-lab-tourist- policy-f73...](https://medium.com/@donhopkins/mit-ai-lab-tourist- policy-f73b77075631)

With commands like :WHOIS, :WHOJ, :LUSER, :SEND, :OS, :PEEK and :UNTALK, ITS was the original social network.

In the HN "The Enduring Legacy of Zork" discussion, another tourist ZEMON told me he used the same NBS TIP as I did, to dial into the ARPANET without a password, connect to MIT-DM, :OS spy on other people playing Zork until it was your turn, then finally play Zork while the other people waiting watched.

MIT-DM was like a 300 BAUD ASCII version of Twitch!

Then he got seduced by networking and Lisp -- and he still uses Emacs too!

[https://news.ycombinator.com/item?id=15081626](https://news.ycombinator.com/item?id=15081626)

>MIT's friendly, unparanoid attitude towards people using their systems and basically just digging their technology was very formative in my career. Zork was the hook. I came to play adventure games, I stayed to learn Emacs and a bit about networking and LISP. I don't use PDP-10s anymore, but I work in the games industry, use Emacs every hour of my working day, and wish I could write more production LISP (though if you squint at Javascript just right...)

At the lab, the Knight TV displays let you watch anyone else's screen, and there was global "free display" screen saver showing all logged in users, what they were doing, where they were, free Lisp Machines, and other useful information, like the time and birthday announcements. They could also buzz open the door from the elevator lobby, and summon the elevator to your floor!

[http://dspace.mit.edu/bitstream/handle/1721.1/41180/AI_WP_23...](http://dspace.mit.edu/bitstream/handle/1721.1/41180/AI_WP_235.pdf;sequence=4) (page 22)

[https://github.com/PDP-10/its/issues/279](https://github.com/PDP-10/its/issues/279)

ROBG was interviewed in the "Get Lamp" documentary on Zork, and eloquently described the experience.

[https://archive.org/details/getlamp- rgriffiths](https://archive.org/details/getlamp-rgriffiths)

>Rob is a perfect example of the benefits of not going just for "names" in a documentary about a wide-ranging subject - nothing on his resume says he was a big text adventure game player or person who was at the beginning of Zork. But there he was, a kid who had gotten into the MIT lab and seen early Zork being played and the effect it was having on the students and computer lab users. He was articulate and provided a wonderful dash of emotion into the descriptions which I used liberally in GET LAMP. He had a number of printouts which I also filmed (but didn't use). Many documentaries wouldn't count "just a player" as worth interviewing - Rob is proof that approach is short-sighted indeed.

[http://www.getlamp.com/](http://www.getlamp.com/)</comment>


RADV: An open-source Vulkan implementation for AMD graphics cards - <AUTHOR> https://github.com/airlied/mesa/tree/semi-interesting/src/amd/vulkan <comment><AUTHOR> Announcement by Dave Airlie: [https://lists.freedesktop.org/archives/mesa- dev/2016-July/12...](https://lists.freedesktop.org/archives/mesa- dev/2016-July/123861.html)

I was waiting for an open source driver to appear when I realised I should really just write one myself, some talking with Bas later, and we decided to see where we could get.

This is the point at which we were willing to show it to others, it's not really a vulkan driver yet, so far it's a vulkan triangle demos driver.

It renders the tri and cube demos from the vulkan loader, and the triangle demo from Sascha Willems demos and the Vulkan CTS smoke tests (all 4 of them one of which draws a triangle).

There is a lot of work to do, and it's at the stage where we are seeing if anyone else wants to join in at the start, before we make too many serious design decisions or take a path we really don't want to.

So far it's only been run on Tonga and Fiji chips I think, we are hoping to support radeon kernel driver for SI/CIK at some point, but I think we need to get things a bit further on VI chips first.

The code is currently here: [https://github.com/airlied/mesa/tree/semi- interesting](https://github.com/airlied/mesa/tree/semi-interesting)

There is a not-interesting branch which contains all the pre-history which might be useful for someone else bringing up a vulkan driver on other hardware.

The code is pretty much based on the Intel anv driver, with the winsys ported from gallium driver, and most of the state setup from there. Bas wrote the code to connect NIR<->LLVM IR so we could reuse it in the future for SPIR-V in GL if required. It also copies AMD addrlib over, (this should be shared).

Also we don't do SPIR-V->LLVM direct. We use NIR as it has the best chance for inter shader stage optimisations (vertex/fragment combined) which neither SPIR-V or LLVM handles for us, (nir doesn't do it yet but it can).

If you want to submit bug reports, they will only be taken seriously if accompanied by working patches at this stage, and we've no plans to merge to master yet, but open to discussion on when we could do that and what would be required.</comment>


ESports Fortnite Player, BreezeAgent Wins $50k in Fortnite Secret Skirmish Event - <AUTHOR> The "Secret Skirmish" is an invitational Solo tournament organized by Epic Games and had take placed on February 15, 2019. 100 Players had to compete for a prize pool of $1,000,000 Dollars. Mohamed Bah or BreezeAgent had also been involved in the LAN Event with 99 Other players trying to win a prize pool. The Event had lasted for 2 Days and had 5,000 fans attend to the stage.
Epic Games additionally live streamed the event on Twitch and YouTube, Both cumulated 200,000 viewers.
Mohamed had come across challenges to be able to win some of the prize pool. Being able to get a victory royale was difficult but he was able to do it and had won $50,000 Dollars on the Solo's event. Once again though he had grabbed enough eliminations to keep himself in the fight and went towards match three with a tie for first.
Mohamed Bah is 16 Year old Professional E-Sports Player. He been competing for 3 years now for games like Fortnite and Black Ops 4. He had called himself BreezeAgent as a Player name. Mohamed Bah usually live streams his game plays on his Twitch verified account with over 25,000 Followers. Mohamed Bah has cumulated with over $60,000 winnings in total of his career.
His Social media accounts are on the rise as he had played a game of Fortnite with the famous Twitch streamer 'Ninja'. Ninja has over 12 Million followers on Twitch and 21 Million Subscribers on YouTube. Mohamed was able to play a game of Fortnite with him and had won a game. Ninja had described him as a 'talented player' and grasped him on his Twitch and Instagram @BreezeAgent. <comment><AUTHOR> Nice One</comment>


Announcing Confident Learning: Finding and Learning with Dataset Label Errors - <AUTHOR> https://l7.curtisnorthcutt.com/confident-learning <comment><AUTHOR> Hi, Hackers. I'm excited to share confident learning for characterizing, finding, and learning with label errors in datasets. To promote and standardize future research in learning with noisy labels and weak supervision, I've also open-sourced the cleanlab Python package: [https://pypi.org/project/cleanlab/](https://pypi.org/project/cleanlab/)

Post: [https://l7.curtisnorthcutt.com/confident- learning](https://l7.curtisnorthcutt.com/confident-learning)

Paper: [https://arxiv.org/abs/1911.00068](https://arxiv.org/abs/1911.00068)

Code: [https://github.com/cgnorthcutt/cleanlab/](https://github.com/cgnorthcutt/cleanlab/)

Abstract: Learning exists in the context of data, yet notions of confidence typically focus on model predictions, not label quality. Confident learning (CL) has emerged as an approach for characterizing, identifying, and learning with noisy labels in datasets, based on the principles of pruning noisy data, counting to estimate noise, and ranking examples to train with confidence. Here, we generalize CL, building on the assumption of a classification noise process, to directly estimate the joint distribution between noisy (given) labels and uncorrupted (unknown) labels. This generalized CL, open-sourced as cleanlab, is provably consistent under reasonable conditions, and experimentally performant on ImageNet and CIFAR, outperforming recent approaches, e.g. MentorNet, by 30% or more, when label noise is non-uniform. cleanlab also quantifies ontological class overlap, and can increase model accuracy (e.g. ResNet) by providing clean data for training.</comment>


Show HN: Landing page optimisation for small business and startups - <AUTHOR> https://landing-page-specialist.io <comment><AUTHOR> Hey!

I'm Ely, the maker of Landing Page Specialist. We are a service that is mainly focused on small businesses and start-ups to help improve their current landing page, website or design to generate more conversion.

In short; We start with a 15 minute intake talk to learn more about your business, based on the AIDA sales funnel we define your goals, create the ideas, create your design and test the new ideas and report on that.

Any feedback is welcome as I am looking to improve.

Cheers, Ely

\-----

Here is some more background information if you are interested:

Inspiration The main motivating factor was that I could not find an interesting business that offers cheap and simplified solutions to improve conversion. It always starts with expensive consulting, deep reporting and long execution before getting results. I know it's a tricky business with a wide range of tasks and tweaks but if you take the right approach there is a way to offer good things for a lower price.

Problem I used to work at companies that offer conversion rate optimization. We had to refuse many smaller customers because our prices were too high. We could not lower our prices or offer a custom price because of the workload we had when using our processes to improve their websites. Small businesses and start-ups often need to search on Google to find solutions on how to fix their landing page to generate more conversion. There is a ton of tools out there but not everyone has the know-how how to use them or even execute the results.

Solution I put a lot of effort and time into this service to come up with a way to offer 3 types of solutions for small prices and give a big return.</comment>


Thunix Shell Provider and Web Host - <AUTHOR> https://www.thunix.org <comment><AUTHOR> There is another Shell Provider and Web Host in existence and it's without a doubt one of the best, most powerful, most reliable and stable Shell Provider and Web Host in the world! It runs OpenSUSE Leap 42.2 64-bit and it has an Intel i7 Quad Core processor at 4GHz, 64GiB of RAM, 1TiB of SSD, and 6TiB of HDD. The network connection is 1Gigabit/s of downstream and 1Gigabit/s of upstream. It has many many things installed and it's free for 30 days. Give it a try and I'm sure you will love it as much as others do.</comment>


Implementing Mixins in Smalltalk (1996) [pdf] - <AUTHOR> http://esug.org/data/HistoricalDocuments/TheSmalltalkReport/ST07/14mo.pdf <comment><USER2> The implementation forwards unknown messages to the first mixin that implements the message, if any. I think forwarding messages through #perform: is very much slower than sending messages directly.

Are there Smalltalk implementations that optimize #perform:? How? Are there implementations that look for forwarding patterns of #doesNotUnderstand: + #perform:, and that add the destination to the inline cache of the original send?</comment>


Evolving a Decompiler - <AUTHOR> http://storm-country.com/blog/evo-deco <comment><USER2> I'm curious to see what the decompiler would show if it were run over binaries produced by Go or Rust. This might be an invaluable tool to help programmers in higher level languages than C understand what _really_ goes on under the hood.

<comment><USER3> I haven't tried it, but I would be very surprised if it yielded good results for go code. Go assembly, from what I've seen, looks _very_ different from the assembly produced by a C compiler. In particular, the calling convention will be different and everything involving strings or other non-integer types will be completely different.

<comment> matt-noonan Actually, I'd expect Go to work really well! Not if you tried to generate C code that compiles to a given Go binary, of course.

But that's not what you'd do. Instead, you'd use the Go compiler as the black box, and learn Go code to produce the given binary. And for that, Go might work better than C: the speed of the compiler would help churn through generations that much faster.

<comment><USER4> Is go compilation that much faster?

<comment><USER5> Go compilation prioritises compile speed over executable speed by default. It's very fast.

<comment><USER4> Is it faster than gcc -O1?

<comment><USER5> From memory yes, it's a lot faster. Compile/link of programs with a few thousand lines of code typically takes on the order of a fraction of a second to a second.

</comment></comment></comment></comment></comment></comment></comment><comment><USER3> This looks really nice, but I think it will be hard to scale for larger binaries that contain significant amount of non-trivial algorithms (and not just copy-pasted stackoverflow answers). But this could still be useful the decompile individual functions / groups of functions.

One good application for this might be targets where there are no good existing decompilers for, such as some of the microconroller instruction sets. As long as you have a compiler for it (which you probably have if the architecture is used) this technique works. Also, code for microcontrollers is often unoptimized which should make the assembly prodiuced by the compiler more deterministic.

</comment><comment><USER6> Really cool project. I've been thinking about this problem for a few years now, and have often wanted to try something very similar. Two years ago I posted a comment on HN [0] outlining my thoughts on how a system similar to this could be used for vulnerability mining, by decompiling security patch bindiffs and looking for other software with binary regions similar to the one patched with the security update.

The idea of decompiling code into human readable form has a certain romance to it. Taken to its extreme, it's the first step in enabling an AI to write a program.

Most researchers are too scared to touch the problem because getting it "perfect" is almost certainly NP-hard, effectively impossible. So kudos to you for trying these techniques. The success you've seen, however limited, certainly pushes the boundaries and hopefully gets more people interested in this problem space.

There is a lot of cool stuff you can do with decompilation. Despite it being a hard problem, you've demonstrated that there are many shortcuts and heuristics we can use to make solving it easier.

I really liked the quote you cited from Gabel and Su:

> general lack of uniqueness in software at levels of granularity equivalent > to approximately one to seven lines of source code [...] crossing both > project and programming language boundaries.

That is the key point that makes this research viable IMO. Programmers are not writing unique code, because they depend on idioms and conventions that are the most "human readable" way of expressing certain bundles of logic. Think how many times you've written a for loop that breaks on a condition, for example. Or an if(a && !b) {...} else {...}.

I'm not surprised at all that so many lines of code are just reinventing tiny wheels over and over again, because ultimately those 1-10 line snippets of control structures are the second-order building blocks of programming. Simplifying things a bit, the only changes between implementations of a common idiom are the variable names and scope, because these are what contextualize the idiom to a human reader. But the compiler doesn't care about that.

[0] [https://news.ycombinator.com/item?id=11573547](https://news.ycombinator.com/item?id=11573547)

</comment><comment><USER7> Having read the paper, this effort, while interesting, does raise some red flags as to how viable the approach actually is.

The first big one is that their approach relies on matching the compiler and flags. While they claim that this is relatively easy to find (though the cited paper doesn't attempt to match flags), there is no indication of what the impact of not having, or having incorrect, information will do to the results. I'm left to guesstimate from their main experiment.

Let's talk about that. It seems that a substantial fraction of the good results comes from having a substantially correct seed. Without having any decompiler helpers, they were able to byte-equivalently decompile exactly 4 programs, one of which was hello world. With the decompiler's output as a seed, they got 10 programs--with the decompiler's output providing byte- equivalent output for 6 of those. Without an oracle for program correctness, it's hard to get an idea of what, say, a 60% equivalent program really means, especially. Having their example say "the answer was argv[i], but we did _argv instead " is concerning--it's not implying that close is accurate.

One thing that's completely understated: they had to seed values. Having to seed strings is understandable, but then they give the example of the compiler-generated (x + x + x) << 2 for 12 _ x. The Project Euler example they couldn't decompile is "largest prime factor", and given that they did it worse on optimized than the unoptimized binary, I'm guessing that there's some small constant division and/or modulo operations that they can't seed.

The examples they evaluate on are tiny--the largest one is 88 lines (I'm guessing that's including whitespace and #include <stdio.h> judging from the size of hello world). They also look guaranteed not to trigger many advanced compiler optimizations (e.g., vectorization). It would be more interesting and useful to see the results on code from programming computations or things like the benchmark game which are somewhat designed to exercise more advanced features.

Scaling is, as others noted, not evidenced at all. They claim that it should be solved by doing functions individually, but it is worth noting that even trying to _find_ the functions is a very challenging problem in decompilation. Moreover, interprocedural optimizations are an important part of optimizing compilers, and some of those kinds of optimizations are not going to be easily derived from a function-by-function approach (devirtualization comes to mind).

At the end of the day, while intriguing, this approach doesn't seem fruitful. The quality is still quite poor, despite running on very tiny programs. There's no evidence for being able to handle advanced compiler techniques (such as vectorization), and some a priori reasons to doubt its ability to handle it. It doesn't free the decompiler writer from having to put a fair amount of effort into solving hard problems (identifying functions), nor does it free them from having to do brittle pattern matching (the extent to which it is necessary is not made clear).

</comment><comment><USER8> I recently had an idea for doing something like this with encoded/somehow transformed/encrypted natural language documents—anyone know if such things already exist?

<comment><USER9> This class of tasks is called _sequence2sequence_ (sometimes _seq2seq_ ) in machine learning. It's a standard example used by many tutorials. Here's one for Keras: [https://blog.keras.io/a-ten-minute-introduction-to- sequence-...](https://blog.keras.io/a-ten-minute-introduction-to-sequence-to- sequence-learning-in-keras.html)

</comment></comment><comment><USER10> That's actually a really cool application of machine learning.</comment>


Douglas Hofstadter-Intertwined Patterns of Integers&Patterns OfThought Processes - <AUTHOR> http://vimeo.com/album/3082332/video/109139374

<comment><AUTHOR> From the abstract:

Abstract: As a math-loving teen-ager, I got swept up into an intense and almost indescribably intoxicating binge of mathematical exploration, all of which was centered on the discovery (or invention?) of integer sequences. The very first discovery in this binge came out of an empirical exploration of the way in which triangular numbers intermingle with squares, and the discovery of the strange hidden order in the sequence that reflected their intermingling was extremely unexpected and exciting to me.

This huge burst of joy instantly gave rise to the desire to repeat the experience, which meant to recreate essentially the same phenomenon again, but in a new "place", which meant to generalize outwards, and I carried out this generalization by exploring all sorts of "nearby" analogues, where the words "place" and "nearby" of course suggest (at least to mathematically inclined folk!) some kind of metaphorical, but perhaps objective, space of ideas, and in it, some kind of metaphorical metric.

Over the next few years, analogies and sequences came to me in wondrous flurries, giving rise to all sorts of discoveries, some very rich and inspirational to me, some of course less so, but in any case, these coevolving discoveries constantly pushed the envelope of richly-interconnected ideas outwards, revealing new and unsuspected caverns in this mysterious idea-space that I had stumbled upon. Some of my explorations gave rise to patterns that I could fully understand and prove, whereas others gave rise to mysterious, chaotic behaviors that were far too deep for me to fathom, let alone prove. After a while, I started hitting up against the limits of my own imagination, and thus, sadly, I gradually ran out of steam, but the several-year voyage had been incredible one of the greatest voyages in my life.

The talk will thus be all about the very human, intuition-driven, analogy- permeated nature of mathematical discovery, invention, and exploration not at the immensely abstract level of great mathematicians, to be sure but hopefully, the essence of the mental processes mediating the modest meanderings of a middling, minor mathematician is more or less the same as that of those that mediate the marvelous and majestic masterstrokes of a major, mature mathematician.</comment>


Cloudinary's jQuery plugin for embedding and transforming images - <AUTHOR> http://cloudinary.com/blog/cloudinary_s_jquery_library_for_embedding_and_transforming_images

<comment><AUTHOR> This blog post introduces Cloudinary's jQuery plugin for easily embedding images and transforming images in the cloud using Javascript.

As web developers, we closely monitor the shifts in today's modern web applications architecture stack. We find the client vs. server-side HTML rendering debate particularly interesting.

We really wanted to help simplify image management for Javascript developers - client-side rendering and node.js developers alike.</comment>


The Mill Blackbird - <AUTHOR> https://m.youtube.com/watch?v=OnBC5bwV5y0 <comment><AUTHOR> Another hit for the seeing-is-believing crowd. Automobile VR platform.

More at Autoblog: [http://www.autoblog.com/2016/06/23/mill-blackbird-car-rig- vi...](http://www.autoblog.com/2016/06/23/mill-blackbird-car-rig-video/)

And The Mill's website: [http://www.themill.com/portfolio/3002/the- blackbird%C2%AE](http://www.themill.com/portfolio/3002/the-blackbird%C2%AE)

 _The Blackbird is the world 's first fully adjustable car rig that cannot only alter its chassis to match the precise length and width of almost any car, but its looks as well. Using CGI, the car rig can be re-skinned to look like any car, and its electric motor can be programmed to emulate the driving characteristics of the subject car, too. Automotive content producers no longer need the physical vehicle for a shoot as the Blackbird is a do-it-all- rig._</comment>


Check this when you have time - <AUTHOR> http://paulgraham.com/webgen.html

<comment><USER2> From source:

"This was our first logo. I won't mention the name of the designer, because he threw it together in a few minutes and wasn't especially proud of it.

The logo was designed to be centered, because centering was the only formatting that existed then. Netscape had not yet introduced tables.

The address was my apartment. It was a calculated risk to leave off the apartment number.

You don't see a lot of startups based in Manhattan. The address seems even more anomalous if you know the neighborhood."

</comment><comment><USER3> ?</comment>


End to End Machine Learning Pipeline Tutorial - <AUTHOR> https://spandan-madan.github.io/DeepLearningProject/ <comment><USER2> Reading articles like this written by people who want to share their fabulous domain knowledge for free of charge really is the reason why I read Hacker News. Thank you, i hope i will have the time to read through it all with thought and later hopefully utilize it with my own projects.

<comment> spandan-madan And people like you who take time out to read and learn is exactly the reason why people like me write such articles! Absolutely thrilled that people liked it and that I will be contributing in people learning this beautiful field of science I do research in :)

<comment><USER3> Thanks for putting so much time and effort into this. This is definitely not "Yet-another-intro-to-ML".

</comment></comment></comment><comment><USER4> Hi! This is really great page, I love reading it. Just a few tips:

The for loops in your code can be made more conscise: instead of

      for i in range(len(movies_with_overviews)):
          movie=movies_with_overviews[i]

you can write

      for movie in movies_with_overviews:

Also, at around In[82], you don't declare Y, but still reference it at the train-test split. Another way to do the train-test split is by using the train-test split in scikit-learn: [http://scikit- learn.org/stable/modules/generated/sklearn.mod...](http://scikit- learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)

</comment><comment><USER5> These are the tutorials that depict the reality of a machine learning career. Everyone broadly understands that data preparation is the key, but few realize what that involves. Half of this tutorial is just about getting and prepping data for training. Kudos!

<comment> spandan-madan To quote one of the greatest professor in ML Pedro Domingos - "First-timers are often surprised by how little time in a machine learning project is spent actually doing machine learning. But it makes sense if you consider how time- consuming it is to gather data, integrate it, clean it and pre-process it, and how much trial and error can go into feature design.....Learning is often the quickest part of this, but that's because we've already mastered it pretty well! Feature engineering is more difficult because it's domain-specific, while learners can be largely general-purpose."

</comment></comment><comment><USER6> This so so helpful. It would take me months to gather resources to learn this stuff and I wouldn't even know what I would be looking for. To the author: please share more content if your valuable time permits

<comment> spandan-madan Working on them already! Next one is going to be on Word Embeddings for Natural Language Processing. Basically, how do we convert words and sentences to numbers so that a computer can work with them. Applications like Text classification, sentiment analysis all of them depend on this one single fundamental backbone!

<comment><USER7> That sounds great! Hope to catch it on here when you post it, thanks again for this tutorial - it's a fantastic resource.

</comment></comment></comment><comment><USER8> Great write-up. Especially the fact that half of it was about finding cleaning and structuring data! You can tell someone isn't applying ML if they aren't spending most of their time getting their data organized. It's the "sharpening the axe" part of the hour Lincoln describes.

 _For example, they never introduce you to how you can run the same algorithm on your own dataset_

I actually think the tensorflow tutorial on CNNs actually runs through training and classification on your own set with inception pretty well.

You mention you're a CV student. Any particular area of focus?

<comment> spandan-madan Sure, would love to get in touch about my work over mail! What's your email ID Andrew?

<comment><USER8> firstname.lastname@example.com

</comment></comment></comment><comment><USER9> While much of this goes over my head, detailed write-ups like this by people who have no direct way of gaining a financial outcome from all their hard work is the cornerstone of why the internet is fantastic.

Amazing work!

</comment><comment><USER10> I have been searching for exactly this type of tutorial for months. Your explanation of the state of online "10 minute introductions" for machine learning is spot on. I understand the concepts, and have a thorough background in programming, yet there always was a gap in my knowledge base. Thank you for sharing this!

</comment><comment><USER11> This is wonderful. I just became interested in this subject but had difficult finding resources that weren't simple copy/paste examples, as you mentioned, or semester-long courses. Thank you!

</comment><comment><USER12> I saw this tutorial by you somewhere Spandan, and found it here on HN. I am yet to explore it but I have marked your GIT repo already. Thanks for the hard work.

</comment><comment><USER13> Are there more great resources like this to learn finding, cleaning and structuring data? Would greatly appreciate it if someone could point me in a direction.

<comment> spandan-madan Hi!

I couldn't find much, that's why I stressed on it in the tutorial. Scraping is a fun hobby but it's extremely useful. I strongly suggest spending time using python's selenium and beautiful soup libraries. The former is good to automate pages with javascript elements, and the latter to parse HTML!

</comment></comment><comment><USER14> Spandan, this is fantastic and detailed write up. Kudos! And thanks for investing your time to do this!

</comment><comment><USER15> This looks amazing, thankyou for sharing! :)

</comment><comment><USER16> Very nice work. Thanks for sharing.

</comment><comment><USER17> Amazing piece of work</comment>