Infoman

Member since 2017-07-15T03:50:57Z. Last seen 2025-08-21T09:12:55Z.

2756 blog posts. 128 comments.

Followers: 0 Following: 2

Posts by Infoman

• 
  

  Infoman

  Full Stack Hello World Voting Ethereum Dapp Tutorial — Part 1

  https://medium.com/@mvmurthy/full-stack-hello-world-voting-ethereum-dapp-tutorial-part-1-40d2d0d807c2

  In my previous post, I explained the high level architecture of Ethereum platform comparing it to a web application. As a developer, the best way to learn any new technology is by diving in and building toy applications. In this post, let’s build a simple ‘Hello World!’ application which is a Voting application.

  The application is extremely simple, all it does is initialize a set of contestants, let anyone vote for the candidates and display the total votes received by each candidate. The goal is not to just code an application but to learn the process of compiling, deploying and interacting with it.

  I have deliberately avoided using any dapp frameworks to build this application because the frameworks abstract away lot of the details and you fail to understand the internals of the system. Also, when you do use a framework, you will have more appreciation for all the heavy lifting the framework does for you!

  In lot of ways, this article is a continuation of the previous post. If you are new to the world of Ethereum, I recommend reading it before continuing.

  The goal of this exercise is to:

  Set up the development environment. Learn the process of writing a contract, compiling it and deploying it in your development environment. Interact with the contract on the blockchain through a nodejs console. Interact with the contract through a simple web page to display the vote counts and vote for candidates through the page. The entire application set up and build was done on a fresh installation of ubuntu 16.04 xenial. I have set up and tested the application on macos as well.

  This is how I would visualize this application we are going to build.

  1. Setting up the development environment Instead of developing the app against the live blockchain, we will use an in- memory blockchain (think of it as a blockchain simulator) called testrpc. In Part 2 of the tutorial, we will interact with the real blockchain. Below are the steps to install testrpc, web3js and start the test blockchain on a linux operating system. The exact same instructions work on macos as well. For windows, you can follow the instructions here (Thanks Prateesh!).

  Note: This tutorial currently works with web3js version 0.20.1. Instead of running npm install ethereumjs-testrpc web3 run npm install ethereumjs-testrpc web3@0.20.1 . I will update the tutorial once web3js 1.0 stable is released

  Notice that the testrpc creates 10 test accounts to play with automatically. These accounts come preloaded with 100 (fake) ethers.

  1. Simple voting contract We are going to use the solidity programming language to write our contract. If you are familiar with object oriented programming, learning to write solidity contracts should be a breeze. We will write a contract (think of contract as a class in your favorite OOP language) called Voting with a constructor which initializes an array of candidates. We will write 2 methods, one to return the total votes a candidate has received and another method to increment vote count for a candidate.

  Note: The constructor is invoked once and only once when you deploy the contract to the blockchain. Unlike in the web world where every deploy of your code overwrites the old code, deployed code in the blockchain is immutable. i.e, If you update your contract and deploy again, the old contract will still be in the blockchain untouched along with all the data stored in it, the new deployment will create a new instance of the contract.

  Below is the voting contract code with inline comment explanation:

  Copy the above code to a file named Voting.sol in the hello_world_voting directory. Now let’s compile the code and deploy it to testrpc blockchain.

  To compile the solidity code, we will first install npm module called solc

  mahesh@projectblockchain:~/hello_world_voting$ npm install solc We will use this library within a node console to compile our contract. Remember from the previous article, web3js is a library which lets you interact with the blockchain through RPC. We will use that library to deploy our application and interact with it.

  First, run the ‘node’ command in your terminal to get in to the node console and initialize the solc and web3 objects. All the code snippets below need to be typed in the node console.

  mahesh@projectblockchain:~/hello_world_voting$ node

  Web3 = require('web3') web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545")); To make sure web3 object is initialized and can communicate with the blockchain, let’s query all the accounts in the blockchain. You should see a result like below:

  web3.eth.accounts ['0x9c02f5c68e02390a3ab81f63341edc1ba5dbb39e', '0x7d920be073e92a590dc47e4ccea2f28db3f218cc', '0xf8a9c7c65c4d1c0c21b06c06ee5da80bd8f074a9', '0x9d8ee8c3d4f8b1e08803da274bdaff80c2204fc6', '0x26bb5d139aa7bdb1380af0e1e8f98147ef4c406a', '0x622e557aad13c36459fac83240f25ae91882127c', '0xbf8b1630d5640e272f33653e83092ce33d302fd2', '0xe37a3157cb3081ea7a96ba9f9e942c72cf7ad87b', '0x175dae81345f36775db285d368f0b1d49f61b2f8', '0xc26bda5f3370bdd46e7c84bdb909aead4d8f35f3']

  To compile the contract, load the code from Voting.sol in to a string variable and compile it.

  code = fs.readFileSync('Voting.sol').toString() solc = require('solc') compiledCode = solc.compile(code) When you compile the code successfully and print the ‘contract’ object (just type compiledCode in the node console to see the contents), there are two important fields you will notice which are important to understand:

  compiledCode.contracts[‘:Voting’].bytecode: This is the bytecode you get when the source code in Voting.sol is compiled. This is the code which will be deployed to the blockchain. compiledCode.contracts[‘:Voting’].interface: This is an interface or template of the contract (called abi) which tells the contract user what methods are available in the contract. Whenever you have to interact with the contract in the future, you will need this abi definition. You can read more details about ABI here Let’s now deploy the contract. You first create a contract object (VotingContract below) which is used to deploy and initiate contracts in the blockchain.

  abiDefinition = JSON.parse(compiledCode.contracts[':Voting'].interface) VotingContract = web3.eth.contract(abiDefinition) byteCode = compiledCode.contracts[':Voting'].bytecode deployedContract = VotingContract.new(['Rama','Nick','Jose'],{data: byteCode, from: web3.eth.accounts[0], gas: 4700000}) deployedContract.address contractInstance = VotingContract.at(deployedContract.address) VotingContract.new above deploys the contract to the blockchain. The first argument is an array of candidates who are competing in the election which is pretty straightforward. Let’s see what are all in the hash in the second argument:

  data: This is the compiled bytecode which we deploy to the blockchain. from: The blockchain has to keep track of who deployed the contract. In this case, we are just picking the first account we get back from calling web3.eth.accounts to be the owner of this contract (who will deploy it to the blockchain). Remember that web3.eth.accounts returns an array of 10 test accounts testrpc created when we started the test blockchain. In the live blockchain, you can not just use any account. You have to own that account and unlock it before transacting. You are asked for a passphrase while creating an account and that is what you use to prove your ownership of that account. Testrpc by default unlocks all the 10 accounts for convenience. gas: It costs money to interact with the blockchain. This money goes to miners who do all the work to include your code in the blockchain. You have to specify how much money you are willing to pay to get your code included in the blockchain and you do that by setting the value of ‘gas’. The ether balance in your ‘from’ account will be used to buy gas. The price of gas is set by the network. We have now deployed the contract and have an instance of the contract (variable contractInstance above) which we can use to interact with the contract. There are hundreds of thousands of contracts deployed on the blockchain. So, how do you identify your contract in that blockchain? Answer: deployedContract.address. When you have to interact with your contract, you need this deployed address and abi definition we talked about earlier.

  1. Interact with the contract in the nodejs console

     contractInstance.totalVotesFor.call('Rama') { [String: '0'] s: 1, e: 0, c: [ 0 ] } contractInstance.voteForCandidate('Rama', {from: web3.eth.accounts[0]}) '0xdedc7ae544c3dde74ab5a0b07422c5a51b5240603d31074f5b75c0ebc786bf53' contractInstance.voteForCandidate('Rama', {from: web3.eth.accounts[0]}) '0x02c054d238038d68b65d55770fabfca592a5cf6590229ab91bbe7cd72da46de9' contractInstance.voteForCandidate('Rama', {from: web3.eth.accounts[0]}) '0x3da069a09577514f2baaa11bc3015a16edf26aad28dffbcd126bde2e71f2b76f' contractInstance.totalVotesFor.call('Rama').toLocaleString() '3' Try the above commands in your node console and you should see the vote count increment. Every time you vote for a candidate, you get back a transaction id: Example: ‘0xdedc7ae544c3dde74ab5a0b07422c5a51b5240603d31074f5b75c0ebc786bf53’ above). This transaction id is the proof that this transaction occurred and you can refer back to this at any time in the future. This transaction is immutable. This immutability is one of the big advantages of blockchains such as Ethereum. In future tutorials, we will build applications leveraging this immutability.

  2. Webpage to connect to the blockchain and vote Now that most of the work is done, all we have to do now is create a simple html file with candidate names and invoke the voting commands (which we already tried and tested in the nodejs console) in a js file. Below you can find the html code and the js file. Drop both of them in the hello_world_voting directory and open the index.html in your browser.

  If you remember, we said earlier we will need the abi and the address to interact with any contract. You can see above in the index.js file how they are used to interact with the contract.

  This is what you should see when you open the index.html file in your browser.

  If you are able to enter the candidate name in the text box and vote and see the vote count increment, you have successfully created your first application! Congratulations! To summarize, you set up your dev environment, coded a simple contract, compiled and deployed the contract on the blockchain and interacted with it via nodejs console and then through a webpage. Now would be a good time to pat yourself on the back if you haven’t already :)

  In part 2, we will deploy this contract to the public test network so the entire world can see it and vote for a candidate. We will also get more sophisticated and use the truffle framework for development (and not have to use the nodejs console to manage the entire process). Hope this tutorial helped you get a practical idea on how to get started with developing decentralized application on the Ethereum platform.

  As always thanks Raine Rupert Revere for corrections/edits of this post.

  If you run into issues getting the application working, feel free to DM me on twitter @zastrinlab

  If you want a more challenging project, I created a course to build a decentralized eBay on Ethereum & IPFS.

  If you would like to get notified when I write more tutorials, you can subscribe here.

  Thanks to Raine Rupert Revere. EthereumBlockchainTutorial One clap, two clap, three clap, forty? By clapping more or less, you can signal to us which stories really stand out.

  4.7K 137 Follow Go to the profile of Mahesh Murthy Mahesh Murthy Techie, Foodie, Traveler, Founder www.zastrin.com

  Related reads Making Sense of “Cryptoeconomics” Go to the profile of Josh Stark Josh Stark

  2.1K

  Also tagged Ethereum Enigma and Ethlend Partner to bring Secret Contracts to Decentralized Lending Go to the profile of Enigma Project Enigma Project

  2K

  Also tagged Tutorial A Look Back At 2017 (I): Best Web UI Kits, Design Video Tutorials, and UI/UX Designers Go to the profile of linda linda

  739

  Responses Write a response… Applause from Mahesh Murthy (author) Go to the profile of Prateesh Prateesh Jun 17, 2017 Steps to install testrpc in windows 10

  Install Visual Studio Community Edition. If you choose a custom installation, the bare minimum items that need to be checked are all pertaining to Visual C++ (Current version is VS 2017) Install the Windows SDK for Windows (If you are in Windows 10 install SDK… Read more…

  277 6 responses Applause from Mahesh Murthy (author) Go to the profile of Арсений Печенкин Арсений Печенкин Nov 19, 2017 web3.eth.accounts For web3.version ‘1.0.0-beta.26’ this code doesn’t work. You can get accounts by executing this code web3.eth.getAccounts().then(console.log)

  64

  Applause from Mahesh Murthy (author) Go to the profile of Diego Quintana Valenzuela Diego Quintana Valenzuela Oct 25, 2017 Just wondering if this might help someone: I ran into this problem

  web3.eth.accounts Error: Invalid JSON RPC response: undefined at Object.InvalidResponse ... Which is solved having the testrc service up and listening, for example in another terminal. More info in https…

  Read more…

  30 1 response Applause from Mahesh Murthy (author) Go to the profile of Steve Suranant Steve Suranant May 1, 2017 Cant thank you enough for writing this post, I have been struggling to find an updated document as you are. Your post helped me a lot in understanding how everything comes together.

  13

  Applause from Mahesh Murthy (author) Go to the profile of Joe Cotroneo Joe Cotroneo Jan 31, 2017 Thanks for this very helpful introduction to contract coding.

  After running testrpc I was getting an error trying to connect via node on my ubuntu 16.04 VM (using vagrant/virtualbox).

  node

  Web3 = require('web3') web3 = new Web3(new > Web3.providers.HttpProvider("http:… Read more…

  7 1 response Applause from Mahesh Murthy (author) Go to the profile of John Charles McLaughlin John Charles McLaughlin Nov 6, 2017 Thanks so much for the article. As a learning exercise I converted the tutorial contents to 1.0 web3 bindings and set up a one line build for it.

  https://github.com/mjhm/hello_world_dapp

  5

  Conversation with Mahesh Murthy. Go to the profile of Justin Zhang Justin Zhang Aug 17, 2017 Thanks for the tutorial! I have a few questions:

  What is contract.runtimeBytecode? In the code the contractInstance is acquired using abi and address. I wonder why can’t we get the instance using address only and then get the abi from the instance? Finally, is there a tool… Read more…

  1 response Go to the profile of Mahesh Murthy Mahesh Murthy Aug 18, 2017 Here is the difference between bytecode and runtime bytecode: https://www.reddit.com/r/ethereum/comments/3pq08g/some_quick_things_about_verifying_contracts/cw8qn0d/ The contract address is like a pointer to your contract on the blockchain. And your contract is in bytecode so you can’t get ABI from it. Although, in the future… Read more…

  70 2 responses Applause from Mahesh Murthy (author) Go to the profile of Grant Herman Grant Herman Jun 15, 2017 You have done such an amazing job with this. I have read through so many articles and this was just such a good starting place

  3

  Applause from Mahesh Murthy (author) Go to the profile of Grace Tan Grace Tan Oct 23, 2017 Hi all. I got Mahesh’s blessing to post my very simple Node app version of this tutorial, which can be found here: https://github.com/gtan66/voting-dapp. Hopefully this repo will help anyone with version issues, and people who are running into obscure issues.

  Invalid Opcode error:

  Read more…

  17

  Applause from Mahesh Murthy (author) Go to the profile of Arthur Mastropietro Arthur Mastropietro Nov 16, 2017 Great tutorial, congrats for that, you provided a great service for the community.

  For those who are not having votes updated when open in browser and click some votes, don’t forget to update your code with the address where the contract is deployed as pointed at index.js:

  Read more…

  3

  Conversation with Mahesh Murthy. Go to the profile of W. Cameron W. Cameron May 18, 2017 I tried to write your Node REPL contracts commands all in one script and it didn’t work, the deployedContract.address was always undefined. Following your instructions to use the REPL, however, worked perfectly. I’m trying to understand why that might be the case. Could you provide any insight into that?

  1 1 response Go to the profile of Mahesh Murthy Mahesh Murthy May 19, 2017 The only thing I can think of is, the deploy (VotingContract.new) is somehow happening asynchronously in your script. You can try creating a callback function and check the address in that function. Details: https://github.com/ethereum/wiki/wiki/JavaScript-API#web3ethcontract I would be curious to hear what you find out.

  5 2 responses Applause from Mahesh Murthy (author) Go to the profile of josh pierro josh pierro Oct 21, 2017 Here is a pure js and material design port of this excellent tutorial. I look forward to doing the rest on Zastrin!

  https://github.com/joshpierro/ethereum-voting-dapp

  4

  Applause from Mahesh Murthy (author) Go to the profile of MANAS MAHAPATRA MANAS MAHAPATRA Oct 25, 2017 Thanks for this great small hands-on tutorial. I tried this on AWS and could get it working. Initially struggled with the web page running — then I observed while debugging the JS that browser was caching the older contract address. Thanks again!!

  1

  Applause from Mahesh Murthy (author) Go to the profile of Alex Mochu Alex Mochu Nov 16, 2017 This has been very helpful. Thank you

  1

  Applause from Mahesh Murthy (author) Go to the profile of Keith Holliday Keith Holliday Sep 26, 2017 Great post! Thanks for doing the whole example from scratch. It is nice to see how the full stack works without the framework at first.

  1

  Conversation with Mahesh Murthy. Go to the profile of Piyush Ramavat Piyush Ramavat May 19, 2017 Hey Mahesh,

  Thanks for this wonderful post. I had one doubt though. Similar to gas payment for deploying the contract, don’t we have to pay gas for executing the transactions?

  I mean when we call: contractInstance.voteForCandidate(), don’t we’ve to specify gas? I know call(…

  Read more…

  1 1 response Go to the profile of Mahesh Murthy Mahesh Murthy May 20, 2017 You do pay gas for any transactions which change the state. In this tutorial, you are only interacting with testrpc and it has default gas price and limit already set. You are just not explicitly specifying the gas price. Check your account balance, execute a transaction and check again, you will notice the balance would have gone down.

  2

  Applause from Mahesh Murthy (author) Go to the profile of Grady Laksmono Grady Laksmono Nov 25, 2017 Thanks a lot for the tutorial. This should be part of the Ethereum.org Hello World :)

  1

  Conversation with Mahesh Murthy. Go to the profile of Craig Skipsey Craig Skipsey Jan 25, 2017 Could we host the HTML and JavaScript files (and anything else needed for the front end) on IPFS? Making it a truly decentralised “hello world”!

  3 2 responses Go to the profile of Mahesh Murthy Mahesh Murthy Jan 25, 2017 For sure, that would be awesome! I haven’t tried it yet, let me know if you get it working.

  3

  Applause from Mahesh Murthy (author) Go to the profile of Partha SK Partha SK Jul 12, 2017 Tried all the steps and it works perfectly fine! Thanks Mahesh for putting this together.

  1

  Applause from Mahesh Murthy (author) Go to the profile of InverseFunction InverseFunction Jun 28, 2017 Thanks Mahesh.

  Nice article. I was struggling to get this done since long time but due to outdated articles, I was always getting stuck.

  Finally I got this done.

  Thanks a ton again

  1

  Applause from Mahesh Murthy (author) Go to the profile of Jackson Ng Jackson Ng Sep 1, 2017 Murthy, thank you very much for writing this. This is probably the best tutorial I have come across that covers Ethereum, Smart Contract and Truffle.

  I followed your tutorial and made some changes along the way so that I can have it running on Google Cloud and have users execute smart contract through the DApp on their…

  Read more…

  1

  4.7K

  Go to the profile of Mahesh Murthy Never miss a story from Mahesh Murthy, when you sign up f

  2018/01/11
• 
  

  Infoman

  Go to the profile of Mahesh Murthy Mahesh MurthyFollow Techie, Foodie, Traveler, Founder www.zastrin.com Jan 3, 2017 Ethereum for web developers I have been learning about Ethereum blockchain platform for some time and the more I learn, the more exciting it looks. There are lots of resources (articles, videos, platform documentation) about Ethereum, it’s easy to get overwhelmed. But, many of them are outdated understandably because the platform is still evolving at a rapid pace. It took me some time to piece together and get a complete picture of what Ethereum is and how it works. Talking to developers in meetup groups and other online communities, it feels like there are many people who would like to get their hands dirty with this new technology but have the same issue. This article is my attempt at explaining Ethereum from a web developer’s point of view.

  If you are a web developer, you know how a webapp with it’s client server architecture works at a very high level.

  

  You have your web application hosted on a hosting provider like AWS, Heroku or a VPS. All the clients interact with this one central application. Clients can be a browser, another api consuming your service etc. When a client makes a request to the server, the server does it’s magic, talks to the database and/or cache, reads/writes/updates the database and serves the client.

  This architecture works very well most of the times. However, there are certain applications where it would be really helpful if that database was publicly and securely accessible by everyone and you don’t have to rely on this webapp owner for your data.

  For example, let’s look at eBay. If you are a power seller who has earned hundreds of good reviews and for some reason eBay suspends your account. That would be very bad and could severely impact your business. What would be really nice is the ability for you take all your reviews and ratings and move to another platform (say eBay Competitor). eBay does provide a service by being the trusted third party between buyers and sellers. But then, they also take a commission off each sale. What if there was a way to eliminate eBay altogether from the transaction between buyer and seller so you save on commission and also you have access to all your data? This is where decentralized applications come in to picture. Ethereum makes it very easy to build Dapps (decentralized applications).

  This is how an Ethereum Dapp looks at a high level:

  

  If you notice, every client (browser) communicates with it’s own instance of the application. There is no central server to which all clients connect to. This means, every person who wants to interact with a dapp (Decentralized Application) will need a full copy of the blockchain running on their computer/phone etc. That means, before you can use an application, you have to download the entire blockchain and then start using the application. This might sound ridiculous at first but it has the advantage of not relying on a single central server which might disappear tomorrow.

  In reality, you don’t need to spend lot of your hard disk and RAM downloading the entire blockchain. There are a few workarounds/optimizations to keep the application decentralized yet make the interaction quick and easy.

  Now, what exactly is this blockchain? It has:

  Database: Every few transactions that occur in the Ethereum network are packaged in to blocks and each block is linked to the next block. This linked series of blocks which holds all the transaction data is the blockchain. If we go back to the eBay example, every transaction between buyers and sellers, whether it is a sale, refund or dispute would all be recorded on the blockchain and is available for everyone to see. To make sure all the nodes in the network have same copy of the data and to insure no invalid data gets written to this database, Ethereum uses an algorithm called Proof of Work (http://ethereum.stackexchange.com/questions/14/what-proof-of-work-function-does-ethereum-use) Code: The database aspect of blockchain just stores the data. But where is all the logic to buy, sell, cancel, refund etc. In Ethereum world, you write the application code (called contract) in a language called Solidity. You then use the solidity compiler to compile it to Ethereum Byte Code and then deploy that byte code to the blockchain. There are few other alternates to Solidity but Solidity is by far the most popular language for contract development. So basically, the blockchain stores your data, stores the code and also runs the code in the EVM (Ethereum Virtual Machine).

  To build web based dapps, Ethereum comes with a handy javascript library called web3.js which connects to your blockchain node. So you can just include this library in your famous js framework like reactjs, angularjs etc and start building.

  Another big and most important feature is the financial capabilities of the platform. What if I tell you, as soon as you start using a dapp, you get an in built bank account? Actually, not one bank account, but you can create as many bank accounts as you like in a fraction of second? These bank accounts are called wallets where you store money (Ether - the currency used in the Ethereum ecosystem) and transact.

  There are lot of details about the inner workings of the blockchain I left out deliberately because I wanted to concentrate on mostly comparing the blockchain based Dapp with a centalized webapp. Hope this post accomplishes that and gives a good high level idea of what Ethereum is and how it can be used to build decentralized applications.

  I plan on writing more posts/tutorials on dapp development this year. If you would like to get notified, you can subscribe here!

  [I have written a 3 part guided tutorial on building a full stack dapp here: Part1, Part2, Part3]

  I have also created a more complex course to build a decentralized eBay on Ethereum & IPFS.

  Further Reading:

  For in depth details on how Ethereum works you can read the Ethereum white paper. More about the solidity language Solidity Language For all questions, of course you have Ethereum Stack Exchange Super helpful community at gitter: https://gitter.im/ethereum/solidity and https://gitter.im/ethereum/web3.js Thanks @raineorshine, @alwaysbcoding, @kinjalmurthy for feedback on the article.

  2018/01/10
• 
  

  Infoman

  Learn to Code Ethereum DApps by Building Your Own Game

  311 alanfalcon 13 hrs 72

  https://cryptozombies.io/

  news.ycombinator.com/item?id=16113133

  CryptoZombies is an interactive code school that teaches you to write smart contracts in Solidity through building your own crypto-collectables game.

  Get Started, It's Free Learn More

  2018/01/10
• 
  

  Infoman

  Facebook’s Virtual Assistant M Is Dead

  132 mpweiher 22 hrs 75

  https://www.wired.com/story/facebooks-virtual-assistant-m-is-dead-so-are-chatbots/

  news.ycombinator.com/item?id=16110711

  It’s difficult to remember now, but there was a moment in early 2016 when many in the tech industry believed chatbots—automated text-based virtual assistants—would be the next big platform. Messaging app Kik staked its company’s future on bots and “chatvertising.” Startup studio Betaworks launched an accelerator program called Botcamp. And at its 2016 F8 conference, Facebook pitched bots to developers as the best way to connect with 900 million Messenger users.

  Few expected that voice assistants like Amazon's Alexa and Google Assistant would thrive and text-based chatbots would become a punchline. Betaworks’ accelerator lasted one class. Kik pivoted to blockchain technology. And now Facebook says it will shutter M, its buzzy full-service virtual assistant, on Jan. 19.

  In some respects it’s impressive that Facebook kept M running as long as it did. Despite the hype, M, which lived in Facebook Messenger, was presented as an experiment. The free service was only offered to 10,000 people in the San Francisco area, who used it to do things like book restaurant reservations, change flights, send gifts, and wait on hold with customer service. For those that had access, M was a fantastic perk. But for Facebook, it was a cost center.

  That’s because most of the tasks fulfilled by M required people. Facebook’s goal with M was to develop artificial-intelligence technology that could automate almost all of M’s tasks. But despite Facebook’s vast engineering resources, M fell short: One source familiar with the program estimates M never surpassed 30 percent automation. Last spring, M’s leaders admitted the problems they were trying to solve were more difficult than they’d initially realized.

  It was easy for M’s leaders to win internal support and resources for the project in 2015, when chatbots felt novel and full of possibility. But as it became clear that M would always require a sizable workforce of expensive humans, the idea of expanding the service to a broader audience became less viable.

  M's core problem: Facebook put no bounds on what M could be asked to do. Alexa has proven adept at handling a narrower range of questions, many tied to facts, or Amazon's core strength in shopping.

  Another challenge: When M could complete tasks, users asked for progressively harder tasks. A fully automated M would have to do things far beyond the capabilities of existing machine learning technology. Today's best algorithms are a long way from being able to really understand all the nuances of natural language.

  Facebook did succeed in automating some of the work its army of contractors used to perform in the guise of M. If you ask the bot to get flowers delivered, it can automatically get suggestions from online florists, only asking a human to choose which quotes to present to the user.

  Facebook is not left entirely empty-handed. The people who used the service and role-played as the omniscient assistant have generated valuable data that can be used by the company's AI researchers. Using machine learning to make software better at understanding natural language and conversation is one of the group's primary interests.

  “We launched this project to learn what people needed and expected of an assistant, and we learned a lot," Facebook said in a statement. "We're taking these useful insights to power other AI projects at Facebook. We continue to be very pleased with the performance of M suggestions in Messenger, powered by our learnings from this experiment.”

  Chat With Me

  2018/01/10
• 
  

  Infoman

  Turning web design mockups into code with Deep Learning

  166 narenst 5 hrs 60

  https://blog.floydhub.com/turning-design-mockups-into-code-with-deep-learning/

  news.ycombinator.com/item?id=16115353

  Unable to load the content https://blog.floydhub.com/turning-design-mockups-into-code-with-deep-learning/

  2018/01/10
• 
  

  Infoman

  Facebook Dives into Home Device Market with Video Chat Product Named “Portal”

  58 uptown 6 hrs 80

  https://cheddar.com/videos/exclusive-facebook-dives-into-home-device-market-with-video-chat-product-named-portal

  news.ycombinator.com/item?id=16107253

  January 9, 2018

  Facebook is about to jump into the consumer hardware business in a big way with a video chat device named "Portal," which will put it in direct competition with Amazon’s hugely popular line of Echo voice-controlled devices, Cheddar has learned.

  The device is designed to work in the home and represents Facebook’s first serious foray into selling consumer hardware, people familiar with the matter said. Rather than position the device as a smart assistant akin to Amazon’s Echo speakers, Facebook intends to pitch Portal as a way for families and friends to stay connected through video chatting and other social features.

  Facebook plans a formal product introduction in early May at its annual developer conference and hopes to ship the device in the second half of 2018.

  Like Amazon’s screen-equipped Echo Show, Facebook’s Portal is designed to work indoors and be controlled through voice commands. According to people familiar with Facebook’s plans, Portal will be equipped with a wide-angle lens that is capable of recognizing individual faces and associating them with their Facebook accounts.

  The world’s largest social network has been using facial recognition for years and recently started notifying users if their faces appear in photos they aren’t tagged in.

  Facebook also intends to let Portal access outside streaming services like Spotify and Netflix. The company recently signed sweeping music licensing deals with Sony/ATV and Universal Music Group.

  A Facebook spokesperson declined to comment for this story.

  Portal will be the first product to emerge from Facebook’s troubled consumer hardware lab, Building 8. Regina Dugan, the former Google and DARPA exec Facebook hired to lead the division, suddenly departed last year after 18 months on the job. Her exit came as numerous other high-level staffers left the division in 2017.

  Veteran Facebook ad exec Andrew Bosworth was appointed last summer to lead all of the company’s hardware efforts, including its separate Oculus virtual reality business.

  With Building 8, Facebook hopes to eventually sell a suite of consumer products that can compete with offerings from the likes of Amazon, Google, and Apple. Facebook employees have internally referred to the video chat device with the codename "Aloha" but recently settled on the name Portal — an indication that product development has progressed even as there’s been turnover in Building 8’s upper ranks.

  Facebook is currently planning to price Portal at $499 but could decide to lower the price to further spur consumer adoption. (Amazon, by contrast, sells the Echo Show for $230.) CEO Mark Zuckerberg has told employees that he doesn’t care if the device generates profit but rather wants it to change user behavior and encourage phone-like usage among owners.

  Portal will be sold by Facebook through pop-up stores and online, people familiar with the matter said. Facebook’s Oculus VR division is separately planning to release a cheaper standalone headset called Oculus Go this year.

  Reporting by Alex Heath, Cheddar Senior Reporter.

  2018/01/09
• 
  

  Infoman

  Show HN: Hooks Data API – Realtime Data about Thousands of Topics Over Webhooks

  68 krammer 4 hrs 17

  https://data.hooks.co

  news.ycombinator.com/item?id=16108701

  Real World Data in Real Time API

  curl -X POST -d

  '{ "hook_id":"TV_SHOWS_NEW_EPISODES", "topic_id":"game_of_thrones", "when": "1 hour before", "webhook": "https://yourbackend.com/inbound" }' https://api.hooks.co Subscribe to the topic you want and tell us where you want us to push the data, using WebHooks, PubSubHub.

  e.g. Tell us you want to know at your backend when there is a new Game of Thrones episode

  2

  Get updates as webhooks when something important happens about thousands of topics, like weather, sports, events, news... in a single API

  3

  e.g. We will send the game of thrones episode info to the speciefied endpoint 1 hour before its broadcasted.

  Receive structured data only when the event happens. Data is Stored so you can pull it too

  { "id": 242141, "hook_id": "TV_SHOWS_NEW_EPISODES", "topic_id": "game_of_thrones", "when": "1_hour_before", "event_name": "Game of Thrones New Episode: The Dragon and the Wolf", "event_stamp": "2017-08-28T00:00:00+00:00", "event_info": { "url": "http://www.tvmaze.com/episodes/1221415/game-of-thrones-7x07-the-dragon-and-the-wolf", "name": "The Dragon and the Wolf", "season": 7, "number": 7, "airdate": "2017-08-27", "airtime": "21:00", "airstamp": "2017-08-28T01:00:00+00:00", "runtime": 60, "image": { "medium": "http://static.tvmaze.com/uploads/images/medium_landscape/125/314502.jpg", "original": "http://static.tvmaze.com/uploads/images/original_untouched/125/314502.jpg" }, "summary": "Cersei sits on the Iron Throne; Daenerys sails across the Narrow Sea; Jon Snow is King in the North, and winter is finally here." } } 1

  Find what you want to subcribe to within millions of topics among dozens of categories (and growing).

  TV Shows New Episodes

  Rain at a Location

  Concerts from an Artist

  NFL game starts / ends

  Stocks changes

  Bitcoin price change

  Youtube channel new video

  Made for Developers By Developers

  Build more engaging, smarter, better apps

  Join

  We provide the content. With dozens of categories, you can stop wasting time and resources maintaining feeds and APIs polling and parsing infrastructure

  Real-time is king. Make more interactive applications, send marketing notifications or update your content only when something important happens

  Our APIs are simple and we rely on open protocols so that you can switch to and from us very easily. We believe you should choose us, not be forced to use Hooks.io.

  Use Case

  Engagement

  Send better push notifications or email campaigns. It's raining outside? It's a Holiday? Its a good day in the stock market? Get more interactions without having to scrape all that data.

  Use Case

  Big Data & ML Real Time Source

  Our Historic datasets are structured. You can train your models with our data and then use our real-time events to predict better with a more accurate data.

  Use Case

  Marketing Automation

  Publish something, send email campaigns or purchase ads based on the context of each user. It's the superbowl final today? You will sell more. i.e. Game of Thrones episode has aired

  Rain in a Location

  Star Wars The Last Jedi is released Tomorrow

  New Film Releases

  Game is published for Xbox One

  New Game Release

  A new Music Album from Coldplay is released

  New Music Album Release

  Real Madrid game starts and ends

  Soccer Games & Scores

  Patriots game starts and ends

  NFL Games & Scores

  Patriots game starts and ends

  MLB Games & Score

  Patriots game starts and ends

  NBA Games & Score

  A concert from Madonna is scheduled in London

  New Concert

  Game is published for Xbox One

  New Game Release

  New Post at The Verge

  Started raining in Hillsboro

  New TV Show Episode

  Started raining in Hillsboro

  Snow in a Location

  10º Temperature drop in Hillsboro

  Temperature drop

  Weather forcast in Seattle

  Weather forecast

  New Video at PewDiePie Channel

  Youtube Channel

  New Pin at jack/notificationschat-board/

  Pinterest Update

  New Pin at jack/notificationschat-board/

  Twitter Update

  Patriots game starts and ends

  NHL Games & Results

  New Audio at @jack channel

  Soundcloud Channel

  New Audio at @jack channel

  iTunes Podcast Update

  New Review for Hooks

  App Store Review

  Holiday in Texas

  Holidays

  New Film By Tarantino

  Films by Cast

  $APPL Grows 5% in a day

  Stock day Changes

  $APPL is > 200$

  Stock reaches level

  BTC Grows 15% in a day

  Cryto day Changes

  ETH is > 1000$

  Crypto reaches level

  Shop Now

  1 day delivery

  See our amazing TV Catalog

  Chicago Cubs play Tomorrow. Watch the game against Yankees like a Boss.

  Channels

  We are adding new channels every other day. And all of them are modular, you can fine tune your own parameters, tell us if you prefer to receive your data in advance or when the event happens and many more.

  You can also create your own channels or ask us to do it for you. Integrations

  WebHooks

  RSS

  Restful API

  PubSubHubHub

  We provide a wide variety of ways of consuming our API

  Do you have any questions? Ping us at founders@gethooksapp.com

  2018/01/09
• 
  

  Infoman

  Building for the Blockchain

  228 vincentschen 6 hrs 156

  http://blog.ycombinator.com/building-for-the-blockchain/

  news.ycombinator.com/item?id=16107597

  If you’re here, we assume that you’re a developer/hacker who’s intrigued by the blockchain. You’re convinced that you understand how it works and now you’re itching to figure out what the blockchain means for you and your developer skill set.

  If you need more of a primer we’d recommend starting with the bitcoin white paper and Ethereum white paper.

  Our goal in this post is to: 1. Explain how blockchain development differs from existing development paradigms 2. Provide context for the opportunities and challenges in this space

  1. Point you to resources that will give you the foundation to start developing in this new paradigm

  Paradigm Shifts for Developers

  Internet applications benefit from network effects because they maintain centralized silos of information. Built upon shared, open protocols (e.g. TCP/IP, HTTP), companies like Yelp, Facebook, and Amazon benefit from having all of their users – and, as a result, data – in one place. This way they not only have an advantage over competitors with less data but also complete control over the way they monetize the data. In the words of crypto investor Joel Monegro, the current Internet paradigm captures most of its value through fat application layers, whereas the thin, underlying communication protocols capture minimal value.

  Alternatively, the distribution of value in the blockchain paradigm can be described with fat protocols and a thin application layer. This paradigm shift is possible due to the innovation of cryptographic tokens, which are described well by Albert Wagner of USV:

  “Historically the only way to make money from a protocol was to create software that implemented it and then try to sell this software (or more recently to host it)… With [cryptographic] tokens, however, the creators of a protocol can ‘monetize’ it directly and will in fact benefit more as others build businesses on top of that protocol.”

  Previously, the creators of open communication protocols for the Internet, largely DARPA researchers and non-profit contributors, could not align financial incentives with protocol development. In contrast, protocol creators today can issue “tokens”, like Bitcoin and Ethereum, that represent the value of their decentralized protocols.

  Monegro believes that this paradigm shift affects the way that developers should think about their applications: “The combination of shared open data with an incentive system that prevents “winner-take-all” markets changes the game at the application layer and creates an entire new category of companies with fundamentally different business models at the protocol layer.”

  Ethereum

  We’ve come to the understanding that in the blockchain paradigm, developers can capture value through protocol innovation. To continue our discussion, we review how blockchain technologies evolved to eventually cater to developers. Eight years ago, Bitcoin was conceived as a virtual currency that removed the need for centralized financial systems. Initially, developers actually tried building applications upon the Bitcoin blockchain by storing data in the blockchain itself, but it turned out to be pretty inefficient (as described in another old Joel post!). One of these developers, Vitalik Buterin, was frustrated by Bitcoin’s immobilism and risk averse culture for adopting new developer-friendly features. So, he built his own platform, Ethereum.

  While Bitcoin was originally intended to serve as a new medium for financial store of value, Ethereum was invented to serve as a Turing complete developer environment. In Ethereum, developers write smart contracts in the Solidity programming language, and those smart contracts are run in the Ethereum Virtual Machine (EVM). Here, we observe an opportunity for developers to fork and implement their own blockchains to serve different purposes. To do so, however, would require rekindling developer support and network effects that existing blockchain technologies had previously achieved. Today, building on top of existing networks like Ethereum allows developers to become stakeholders in not only their own applications, but also the underlying protocol.

  Dapps, App Coins, and Smart Contracts

  Today’s blockchain developers often build decentralized applications, or dapps, on top of existing protocols to address specific markets and end users. In doing so, developers can issue tokens, or app coins, that are used to execute certain “functions” of the dapps themselves, not unlike Chuck-E-Cheese tokens are used for specific purposes like skeeball. These “functions” are the “smart contracts” that promise a dapp’s services in return for a digital asset, thereby removing the need for a middle-man to ensure the transaction. In other words, smart contracts promise that for one Chuck-E-Cheese token, you can exchange one game of skeeball.

  As the functionality of the dapp becomes more sought after, the fixed number of app coins increase in value as a function of supply and demand. In other words, if it turns out that the Chuck-E-Cheese experience is truly remarkable and highly-demanded, the fixed supply of tokens become more valuable. This is the underlying principle that informs all ICOs (initial coin offerings), in which dapp developers solicit investment by offering app coins in return for capital to fund their projects.

  But wait, you might ask, “Why not use an existing token as opposed to issuing your own, dapp-specific token in the first place?” Dapp-specific app coins enable small-scale economies that facilitate the application’s purpose. These tokens serve as scarce resources that can be regulated and governed to more closely align with the functionality of a dapp. This is where Ethereum comes back into the picture — with Ethereum, developers can very easily issue their own tokens for the specified use of their own dapps.

  Early Opportunities

  With an understanding of the underlying mechanisms of dapps, it’s important to think carefully about how decentralization would benefit your end users. Rather than jumping into a list of side projects, swapping relational databases for blockchain implementations, we urge you to consider the benefits of decentralization. For instance, Augur creates prediction markets by relying on decentralized participants to make correct predictions because they share financial incentives.

  At a meta-level, there are also opportunities for innovation in the developer stack. Many blockchain developers liken the maturity of the blockchain tools and frameworks to those of the web during early days of the Internet. We spoke to Ben Yu of Stream, who described this as a new opportunity for developers: “There is extremely low-hanging fruit in making the field more accessible, and a lot of technical infrastructure needs to be built up to bring blockchain from 1994, in internet terms, to 2017.”

  With the innovation of the blockchain, many have identified the opportunity to build a new, decentralized web stack that does not depend on centralized government or corporate entities. The traditional web stack is composed of building blocks like TCP/IP, DNS, databases, web servers, authentication systems and CDNs, and we are in the midst of replicating these components by using platforms like Ethereum as the base layer.

  Challenges of Immutability

  Unfortunately, a technology that is likened to the early iterations of JavaScript almost certainly comes with challenges, the most apparent of which is related to the immutability of new protocols. Developers cannot change the underlying blockchain or higher-level smart contracts. Libraries or contracts cannot be easily versioned. The recent Parity bug that locked 150MM USD in funds, among many other similar incidents, reminds us of the urgent need to build “future-proof” architectures.

  Brandon Millman, an engineer at 0x, described how blockchain immutability affects the way he thinks about security concerns: “Being in this space means being a lot more careful, especially because people’s money is at risk. Part of the benefit of the blockchain paradigm is that if you’re holding onto your private key, it’s hard for people to take money from you, but a lot of scams are getting you to willingly send your money to the wrong place instead of reaching in to steal money from your wallet.”

  Developers, especially those accustomed to the fast pace of the startup world, are forced to consider tradeoffs between speed and security. As Ben Yu of Stream describes, “You have to move extremely fast, because the space is going enormously fast, but you can’t move fast and break things, which is the traditional philosophy for development being done now. If you break things, you lose hundreds of millions of dollars.”

  Building on the blockchain requires a different level of planning. Developers can no longer apply hot-fixes or overnight patches, because they no longer have centralized control over entire systems. Instead, introducing system changes often involves hard forking entire protocols, or in some cases, providing separate sources for protocol parameters that aren’t tied directly into the blockchain.

  Ethereum’s Limitations

  Beyond the general challenges of immutability, Ethereum includes several limitations that blockchain developers might encounter. For one, Ethereum is unable to access real time data from outside the blockchain. Developers need to rely on trusted third party data providers, called oracles, to provide smart contracts with outside information like weather, random numbers, or currency values.

  Moreover, Ethereum’s specification prevents real-time computations. Processing of block transactions takes upwards of 15 seconds (which is lightning fast compared to Bitcoin’s 10 minutes). As a result, developers need to write asynchronous code with front-end frameworks that can update states accordingly (like React).

  With Ethereum, you are also tied to paying for your transactions by the operation with gas that translates into Ethereum’s ether. As a result, using the current version of Solidity, you could very feasibly find yourself hitting a transaction limit if the computation you intend to perform is too expensive (like verifying checkmate in a game of chess). As a result, on-chain computations because become costly in terms of money and network bandwidth. There are interesting alternatives like Truebit to perform more intensive computation off-chain.

  Getting Started

  In general, it can certainly feel overwhelming getting into this space. It’s an interdisciplinary field, spanning domains of economics, game theory, finance, computer science, math, cryptography, and more. However, that also means that there’s a lot of surface area to contribute.

  Brandon of 0x recommends diving into areas where you have some interest or experience instead of trying to learn everything at once: “If you’ve done JS development beforehand, there are a lot of JS libraries that you can contribute to. While you will definitely need to know [how everything fits together] eventually, you don’t need to feel like you need to take an entire course initially.”

  In the spirit of decentralization, most of the code for projects on the blockchain are also available through open-source. There are a number of good resources to get your hands dirty:

  In addition, the developer communities are remarkably receptive and helpful. Check out:

  /r/ethereum /r/ethdev https://blockgeeks.com/ If you learn primarily by coding up your own projects, here are some ideas to get started:

  Build your own wallet. It can be a be a web, mobile app or desktop app. Create your own ERC-20 token and deploy it on the test net. Modify crypto kitties (dogs, tanks, zombies…) and deploy it on the test net. Looking Forward

  In its current state, yes, blockchain development is messy. No, there aren’t clean frameworks and tools analogous to those that exist for modern web development. But why not see the blockchain’s nascent state as an opportunity to impact a paradigm-shifting technology?

  On the blockchain, you don’t need to deploy any centralized servers, which means that there’s no single point of failure. If your whole stack is decentralized, there is no trusted third party involved making it censorship resistant, and your database is publicly verifiable. As the new paradigm offers opportunity to publicly share data, we observe a supreme advantage to decentralizing databases. This is the future we’re building towards on the Blockchain— where information and power are distributed systematically by cutting out the middleman.

  Comment on Hacker News.

  Thanks to Ben Yu (Stream) and Brandon Millman (0x) for lending their time to be interviewed, and thanks to Niharika Bedekar, Craig Cannon, Claire Shu for reading drafts of this post.

  2018/01/09
• 
  

  Infoman

  Hi

  Hope you're having a great day - I'm Kerman, the founder of The Homework App.

  I want to make The Homework App a great app for you and your teachers to use however I need some help with getting their input.

  I’ve created a short 4 question survey for your teachers, if you could forward this email to your favourite teacher that would be much appreciated! Here is the link to the teacher survey:

  https://www.surveymonkey.com/r/C7MKRYS

  Hope you’re enjoying your school week, let me know if there’s anything you’d like to see improved the app!

  Kindest regards, Kerman

  2018/01/09
• 
  

  Infoman

  [TutorHelp]

  • Home
    • Login
    • Register
  • Startup
  • Page
  • Page1
  • Page2
  • Page3
  • Page4

  2018/01/09
• 
  

  Infoman

  Stanford paper says rent control is driving up cost of housing in San Francisco

  177 nwsm 7 hrs 177

  https://sf.curbed.com/2017/11/3/16603900/rent-control-san-francisco-stanford-study-gentrification

  news.ycombinator.com/item?id=16098402

  Just as California voters might overturn the state’s heavy-handed restrictions on new rent-control units, Stanford economists Rebecca Diamond and Tim McQuade presented a paper in October making the provocative argument that San Francisco rent control ultimately drove rents up citywide since 1995.

  But the conclusion from their findings is not necessarily that rent control is bad. Instead, the findings are a bit more complex.

  In the paper, snappily titled “The Effects of Rent Control Expansion on Tenants, Landlords, and Inequality: Evidence from San Francisco,” Diamond and McQuade used public and private data to look at how often people moved out of rent-control units, how often landlords converted those units to new types of housing not covered under rent control, and how median rents changed since the 1990s.

  The pair singled out SF specifically to “exploit a unique rent control expansion in San Francisco in 1994 that suddenly provided rent control protections for small multifamily housing built prior to 1980” so that renters in post-1980 homes form a natural control group with which to compare.

  Here are some of their conclusions:

  Rent controlled tenants are of course more likely to stay in their current homes. “Rent control increased the probability a renter stayed at their address by close to 20 percent,” note Diamond and McQuade, with younger renters more likely to leave the roost anyway than older ones. And that in turn prevents flight from San Francisco itself. “We find that absent rent control essentially all of those incentivized to stay in their apartments would have otherwise moved out of San Francisco,” note the economists. Yikes.

  However, in some the priciest neighborhoods, tenant turnover in rent-controlled apartments was actually higher. “This evidence suggests that landlords actively try to remove their tenants in those areas where the reward for resetting to market rents is greatest,” either by gamely buying out long term tenants or just evicting them. Landlords of rent-controlled homes were more likely to convert them to the types of buildings not covered by the provisions. “Landlords whose properties were exogenously covered by rent control reduced their supply of available rental housing by 15 percent.” Particularly via the old TIC trick. “Rent-controlled buildings were almost 10 percent more likely to convert to a condo or a Tenancy in Common (TIC) than buildings in the control group, representing a substantial reduction in the supply of rental housing.” Even so, rent control is definitely good for the tenants who get it, even with the added risk of landlord shenanigans. “Rent control offered large benefits to impacted tenants during the 1995-2012 period, averaging between $2,300 and $6,600 per person each year, with aggregate benefits totaling over $390 million annually.” But the loss of housing might drive up rents elsewhere. “We find that six percent decrease in housing supply led to seven percent increase in rental prices. These caused an aggregate welfare loss to renters of $5 Billion. This is almost as large as the benefits accrued by the lucky beneficiaries of rent control.” What does it all mean? First, bear in mind that just because two economists say so doesn’t make it true. But even if we take Diamond and McQuade’s findings as fact, different parties will draw different conclusions.

  San Francisco Area Leads Nation In High Rents For example, the paper says that the cost to general renters was “almost” as high as the benefit to those in rent-controlled homes, but not quite. Is that trade off worth it? That may boil down to a judgment call.

  Some also may respond to the findings by simply suggesting further regulation.

  Jennifer Fieber, director of the San Francisco Tenants Union, told the San Jose Mercury News that the city or state should just make it harder for landlords to shimmy out of rent-control arrangements via TIC conversion, for example.

  On the other hand, those who have griped about rent-control laws all along will point to this research as vindication.

  According to the urban design think tank SPUR, about 45 percent of SF’s housing stock—roughly 172,000 units in 2014—are presently rent controlled, although the city itself keeps no official tally.

  2018/01/09
• 
  

  Infoman

  Canva: Billion-Dollar Valuation Gives Australia Its Only Tech Unicorn 39 dannyw 4 hrs 36

  https://www.bloomberg.com/news/articles/2018-01-08/sequoia-backed-canva-becomes-australia-s-only-tech-unicorn

  news.ycombinator.com/item?id=16100263

  Canva, an Australian-based graphic design app, has raised $40 million to become the country’s only privately backed technology startup to be valued at $1 billion.

  Sequoia Capital took part in the fundraising alongside existing investors Blackbird Ventures and Felicis Ventures. Co-founder Melanie Perkins said the Sydney-based company was profitable and didn’t need the money but was offered terms too good to refuse. The startup, whose apps help advertisers and companies create banners, logos and presentations, plans to double its workforce of 250 staff over the next year, she added.

  “It’d be crazy not to take it,” she said. “We can grow our team as rapidly as we can and know that we’ve got the financial backing to make those decisions very easily.”

  Canva’s latest round of funding makes it a unicorn, a private company valued at $1 billion or more. That’s a rare startup success for Australia’s technology scene: only eight of its listed technology companies are worth more than $1 billion compared with 18 companies in metals and mining alone, according to data compiled by Bloomberg.

  According to Canva’s website, the service has more than 10 million users upload photos or select stock images and use preset filters and fonts to customize designs. It also links with printing providers who can create actual physical banners and displays.

  According to financial records lodged with the Australian Securities and Investment Commission, Canva more than tripled revenue to A$23.5 million ($18 million) and narrowed after-tax losses to A$3.3 million in the 12 months ended June 2017.

  “What this round really enables us to do is to have the jet power just to do absolutely anything that we need to do to make Canva awesome,” she said.

  — With assistance by David Ramli

  2018/01/09
• 
  

  Infoman

  Whiteboard

  https://stackoverflow.com/questions/31781354/share-whiteboard-with-other-user-using-node-js-and-socket-io

  Flowchart:

  Flowchart.js Gojs.io

  Drawing

  http://www.williammalone.com/articles/create-html5-canvas-javascript-drawing-app/

  2018/01/08
• 
  

  Infoman

  news.ycombinator.com/item?id=16088036

  Unpopular but very probably true fact: email can't practicably be made secure, and people should stop trying. Email is itself archaic, and there aren't good reasons people should use it for routine peer-to-peer communications that need secrecy. Why? Because: It's default-plaintext. We don't generally love the way websites ensure they're viewed securely, but email doesn't even have the basic mechanisms HTTP has to prevent secrets from accidentally being sent in the clear. Email encryption is never forward-secure. The most popular standard, OpenPGP, involves a long-term key that is the root of secrecy for all messages from a particular person. Lose that key, ever, and not only is every message you send in the future unsafe, but every message you've ever sent in the past is too. That's a terrible property for a secure messaging system. Email leaks metadata. In fact, some of what we call email "metadata" isn't even metadata --- stuff like subject lines are simply content. They're sent in plaintext. We would never accept a new secure messaging system that behaved like that. Most email users get their email from a website. Unless you make them install something on all their computers --- and at that point, just get them to install Signal, WhatsApp, or Wire --- "encrypting" their email involves schemes in which those websites can get their plaintext mail. * Most email clients are searchable-archive-by-default. Again, if you're using a secure messaging system to keep secrets from a state-level adversary, that's exactly what you don't want. And again, what matters here is the behavior of the overwhelming majority of clients. If you can stipulate a special mail client that is extra-careful, why not stipulate a forward-secure advanced messaging system and stop bothering with email? Everything that makes email effective in the real world makes it inhospitable to secure messaging. We should stop trying to push this particular boulder up this particular mountain and instead just get people to adopt serious secure messengers.

  2018/01/08
• 
  

  Infoman

  Convenient End-To-End Encryption for E-Mail

  257 doener 1 day 140

  https://autocrypt.org

  news.ycombinator.com/item?id=16088036

  e-mail Logo Autocrypt-capable mail apps work with any e-mail provider. You and your friends can use your existing e-mail addresses.

  Encryption Logo Autocrypt is an open specification for e-mail encryption. Under the hood, it uses OpenPGP and other e-mail standards.

  Autocrypt is a set of guidelines for convenient end-to-end-encryption of e-mails. Developers are working on bringing it to several different e-mail programs.

  Does it already work?

  The first specification, Level 1, was released in December 2017. A few mail programs are already capable of Autocrypt, some want to be able of Autocrypt in Spring 2018.

  Please join us in implementing and refining Autocrypt Level 1 and other upcoming specifications. For any further questions or feedback, see our Contact Page.

  Test it now

  2018/01/08