A fantastical idea, inspired by internet legends, comes crashing down Want to make some money? Have you heard the news? The easiest and quickest way to become a full-fledged “entrepreneur.” Start a T-shirt company! A few weeks ago, I stumbled across some articles: How I Built An Online T-Shirt Business In 24 Hours With $24 That Made $347 The First Day How I Built an Online T-Shirt Business and Made $1,248.90 in 3 Weeks How to Start a T-shirt Business in the Next 24-Hours At the time, I was already . So I thought, heck, why not make a t-shirt company from some of my designs? Seems like a quick way to start a mini-business and make some side cash, right? designing a shirt to help me talk to strangers The Experiment: Crafting The Site Launching the t-shirt site was quite simple and, surprisingly, quite fun. Mirroring the , I used amazing user interface and website design to quickly boot up a site. One of Shopify’s third-party apps, , made it dead simple to upload designs for on-demand drop shipping to customers. aforementioned article’s strategy Shopify’s Printful Drop shipping is when shirts are printed on-demand, instead of building up an inventory of t-shirts before customers have committed to purchasing them. It’s more expensive for the store-owner, but better for small-scale operations. Now, I just needed designs. I decided to make a bunch of subtle media references, so that only those who watch the shows would understand. I figured this was niche enough, as well as easily marketable in various online forums. After spending a day with Sketch, I had about 20 or so usable designs. I set the price at an extremely low profit margin — only about $2–3 per shirt, which, if I sold twenty, would make back the cost of launching the site. For me, this project was more of an experiment than an actual money-making business. A couple days later, and the whole site launched! You can still see it now at until I take it down. http://www.minimalshirt.com _Beautiful minimally designed shirts. Media-inspired, made for you._www.minimalshirt.com Minimal Shirts Marketing… and Failing Next up, I had to tell people about the awesome site I made! And unfortunately, this is where those blogs stop offering useful advice. One of the blogs mentions advertising in the subreddit . Not only does this seem to have been a lucky post in his case, but the subreddit currently doesn’t even allow users to post t-shirt products (probably after getting too much spam from people like me). /r/shutupandtakemymoney Well, shit! Where was I going to post these shirts? I posted on my social media platforms, like Facebook. I posted on subreddits specific to each show, ending up with 7–10 different posts on Reddit (which is a bit of a faux pas with the community). I posted in Facebook fan-groups for the various shows, with several thousands of people in each group. I linked to the site in my new blog post. I sent out a newsletter update. I tested out small Google Adwords campaigns. On the positive side, I got a lot of likes and friendly comments! On the negative side, only two of the people that visited my site even tried to put something in their online shopping cart, and zero of them completed the transaction. I tried… and Failed At this point, I ran out of ways to market the site. Then, I realized: Did I really expect to be selling a ton of these? All I did was slap some mildly creative designs on a bunch of t-shirts. Blog posts love to proclaim the ease and simplicity with which anyone can make an online t-shirt business. But it’s not that easy. What the blogs don’t tell you is that they already have thousands of subscribers, connections to high-traffic sites, or a ton of money to blow on advertisement campaigns. Regardless, I had a lot of fun and learned some neat things. Despite what the blogs say, just remember: success isn’t something you can always make in 24-hours. Liked this article? Please 👏 the article below, to show your appreciation 😊. More content like this at . https://www.stephencognetta.com

BUNCH

Facebook

Google

I started my own T-shirt company in 24 hours and made $0

AWS Lambda introduced native support for environment variables (with KMS encryption support). But, using AWS Lambda environment variables makes it hard to share config values across functions and to implement fine-grained access to sensitive data (eg. credentials, API keys, etc.) updated : this post has been updated on 15/09/2017 following the release of Serverless framework 1.22.0 which introduced support for SSM parameter store out of the box. Go to the end of post to see how it compares with other approaches. AWS Lambda for environment variables at the end of 2016. But even before that, the framework had supported environment variables and I was using them happily as me and my team at the time . announced native support Serverless migrated our monolithic Node.js backend to serverless However, as our architecture expanded we found several drawbacks with managing configurations with environment variables. Hard to share configs across projects The biggest problem for us was the inability to share configurations across projects since environment variables are function specific at runtime. The Serverless framework has the notion of , which is just a way of grouping related functions together. You can specify service-wide environment variables as well as function-specific ones. services A sample serverless.yml that specifies both service-wide as well as function-specific environment variables. However, we often found that configurations need to be shared across multiple services. When these configurations change we had to — which in itself was becoming a challenge to track these dependencies across many Github repos that are maintained by different members of the team. update and redeploy all functions that depend on them For example, as we were migrating from a monolithic system piece by piece whilst delivering new features, we weren’t able to move away from the monolithic MongoDB database in one go. It meant that lots of functions shared MongoDB connection strings. When one of these connection strings changed — and it did several times — pain and suffering followed. Another configurable value we often share are the root URL of intermediate services. Being a social network, many of our user-initiated operations depend on relationship data, so many of our microservices depend on the Relationship API. Instead of hardcoding the URL to the Relationship API in every service (one of the deadly ), it should be stored in a central configuration service. microservice anti-patterns Hard to implement fine-grained access control When you need to configure sensitive data such as credentials, API keys or DB connection strings, the rule of thumb are: data should be encrypted at rest (includes not checking them into source control in plain text) data should be encrypted in-transit apply the to function’s and personnel’s access to data principle of least privilege If you’re operating in a heavily regulated environment then point 3. might be more than a good practice but a regulatory requirement. I know of many fintech companies and financial juggernauts where access to production credentials are tightly controlled and available only to a handful of people in the company. Whilst efforts such as the delivers on point 1. it couples one’s ability to deploy Lambda functions with one’s access to sensitive data — ie. he who deploys the function must have access to the sensitive data too. This might be OK for many startups, as everyone has access to everything, ideally your process for managing access to data can evolve with the company’s needs as it grows up. serverless-secrets-plugin SSM Parameter Store My team outgrew environment variables, and I started looking at other popular solutions in this space — etcd, consul, etc. But I really didn’t fancy these solutions because: they’re costly to run: you need to run several EC2 instances in multi-AZ setting for HA you have to manage these servers they each have a learning curve with regards to both configuring the service as well as the CLI tools we needed a fraction of the features they offer This was 5 months before Amazon announced SSM Parameter Store at re:invent 2016, so at the time we built our own Configuration API with API Gateway and Lambda. Nowadays, you should just use the SSM Parameter Store because: it’s a fully managed service sharing configurations is easy, as it’s a centralised service it integrates with KMS out-of-the-box it offers fine-grained control via IAM it records a history of changes you can use it via the console, as well as via its HTTPS API AWS CLI In short, it ticks all our boxes. You can create secure strings that are encrypted by KMS. You can see a history of all the changes to these parameters. You have fine-grained control over what parameters a function is allowed to access. There are couple of to be aware of: service limits max 10,000 parameters per account max length of parameter value is 4096 characters max 100 past values for a parameter Client library Having a centralised place to store parameters is just one side of the coin. You should still invest effort into making a robust client library that is easy to use, and supports: caching & cache expiration hot-swapping configurations when source config value has changed Here is one such client library that I put together for a demo: To use it, you can create config objects with the function. These objects will expose properties that return the config values as (hence the , which is the magic power we get with ). loadConfigs Promise yield co You can have different config values with different cache expiration too. If you want to play around with using SSM Parameter Store from Lambda (or to see this cache client in action), then check out this and deploy it to your AWS environment. I haven’t included any HTTP events, so you’d have to invoke the functions from the console. repo the Serverless framework release 1.22.0 which introduced support for SSM parameters out of the box. Update 15/09/2017: With this latest version of the Serverless framework, you can specify the value of environment variables to come from SSM parameter store directly. Compared to many of the existing approaches, it has some benefits: avoid checking in sensitive data in plain text in source control avoid duplicating the same config values in multiple services However, it still falls short on many fronts (based on my own requirements): since it’s fetching the SSM parameter values at deployment time, it still couples your ability to deploy your function with access to sensitive configuration data the configuration values are stored in , which means you don’t need the KMS permissions to access them, you can see it the Lambda console in plain sight plain text as Lambda environment variables further to the above, if the function is compromised by an attacker (who would then have access to ) then they’ll be able to easily find the decrypted values during the initial probe (go to 13:05 mark on this where I gave a demo of how easily this can be done) process.env video because the values are baked at deployment time, . To make a config value change, you will need to a) ; and b) it doesn’t allow you to easily propagate config value changes identify all dependent functions re-deploying all these functions Of course, your requirement might be very different from mine, and I certainly think it’s an improvement over many of the approaches I have seen. But, personally I still think you should: fetch SSM parameter values at runtime cache these values, and hot-swap when source values change Hi, my name is . I’m an and the author of . I have run production workload at scale in AWS for nearly 10 years and I have been an architect or principal engineer with a variety of industries ranging from banking, e-commerce, sports streaming to mobile gaming. I currently work as an independent consultant focused on AWS and serverless. Yan Cui AWS Serverless Hero Production-Ready Serverless You can contact me via , and . Email Twitter LinkedIn Check out my new course, . Complete Guide to AWS Step Functions In this course, we’ll cover everything you need to know to use AWS Step Functions service effectively. Including basic concepts, HTTP and event triggers, activities, design patterns and best practices. Get your copy . here Come learn about operational for AWS Lambda: CI/CD, testing & debugging functions locally, logging, monitoring, distributed tracing, canary deployments, config management, authentication & authorization, VPC, security, error handling, and more. BEST PRACTICES You can also get off the face price with the code . 40% ytcui Get your copy . here

Amazon

Fetch

Transit

Twitter

YouTube

Ask me for help about serverless

Read My Stories

You should use SSM Parameter Store over Lambda env variables

(This is part 1. Read part 2 on creating silent augmented reality here. ) Data visualization on mobile devices seemed promising, since the time of the first iPhone: very capable portable computers! Innovative touch interaction! Highly localized content! Hundreds of visualizations for mobile devices exist, both as apps and part of daily news content. But there’s one major problem that mobile visualizations couldn’t shake yet: There’s just never enough space. Mobile displays are necessarily small to be portable, and then there’s also fingers in the way. Usually with data visualization, more screen space means better analysis: Data can be shown at a higher resolution, uncovering smaller relationships and parts of the data. It also becomes possible to show multiple charts side-by-side and having coordinated views, quickly flicking to and fro from one lens on the data to the other. It’s the difference between having your chart on a sticky note or across two side-by-side posters. I think that Augmented Reality (AR) could solve this problem. Snapchat Lenses AR has mainly been a research direction for the last thirty-odd years, but is now slowly entering the tech mainstream. AR overlays reality with virtual information, which appears to be part of the environment (depending on your company affiliation, the principle could also be called Mixed Reality). Think: with face tracking, Microsoft’s on your couch table or Apple’s recent . Snapchat Lenses HoloLens letting you play Minecraft ARKit When AR was initially proposed, headsets were usually bulky with low resolutions and low refresh rates. Hickups between head movement and on-screen content made it hard to keep up the illusion of actual virtual elements in your physical world, maybe even leading to cyber sickness. Smartphone production and improvements in leading to lower prices for better components have both revolutionized Virtual Reality (see Oculus) and also Augmented Reality — since they’re both building on similar technologies (small, high-resolution portable displays, head tracking, etc). technology So while our current AR is mostly based on the peephole metaphor (you’re looking through your phone to see face filters or Pokémon), AR - the one we’re interested in for this article - should work with a headset only — hopefully very non-intrusive glasses — leaving your hands free to interact with (augmented) reality. future So how could this future AR solve the lack of screen space for mobile visualizations? By augmenting your reality, AR puts screens everywhere and nowhere at the same time. Screens become fully virtual — with all advantages. Lack of screen space no longer exists, since these virtual screens can potentially fill your whole field-of-view (and beyond). Plus, just like other mobile devices, AR devices know where you are in the world (thanks to geolocation) but even more: where and what your are currently looking at! Combine that with automated object recognition and you have all kinds of fascinating applications for datavis opening up. To be more specific, I can see three promising directions for these future Augmented Reality visualizations: Situated personal visualizations One of the promises of mobile visualizations has always been creating a personalized experience of data. Various apps make use of your location to e.g. center a map on your current position (Google Maps), show restaurants around you (Yelp) or keep track of your running routes (Runkeeper). AR visualization has the potential to become even more personal: knowing about your preferences and goals, it can display the right data at the right time. But what’s even more interesting is that everything can be in the right place: situated Photo by ( ), augmented by the author Osman Rana Unsplash AR Visualizations become part of your environment, augmenting real-world objects (and ) with relevant information, placed at just the right positions. Visualizations are no longer images displayed in little glowing boxes, but augmented textures to the world. people Imagine trying to make your way across Boston in a snow storm. Your app knows exactly where you want to go and can draw from relevant information from the internet. It also knows that you’re at a bus right now and helps you in making decisions: should I get on the bus or take an Uber? Do I have to hurry? Where do I have to transfer? How long will it take? And will this snow ever end? looking All this information is right where you need it and completely private — no one else can see what you see. It’s the ultimate expression of personal visualization. I like to see this development as a form of empowerment, if we get it right (if not: see the of or various dystopian SciFi). works Keiichi Matsuda Similarly, AR vis can show data that’s relevant to you but maybe not to everybody. Photo by , augmented by the author Flako You might be wandering along the aisles of your supermarket, being bombarded by messages of abundance. Package design in recent years hasn’t necessarily developed towards making nutritional information easier accessible. I value the hours I spend staring at small print labels, results of months of heated discussions between industry and administration. While there are freely available, typing product names into a search box, selecting the right one, checking the info and repeating it for every sparkly box on the shelf sounds … unappealing. databases for nutritional information What if the machine could help you with that, take your own preferences when it comes to nutrition (and dietary restrictions to boot) and display a simple heat map, pointing you at just the right products? Once this filtering is done you can still go through the final candidates and make your own, much more informed, decision. And everyone gets their own custom heatmap, since there’s more than enough space for that in virtuality. What all these projects have in common, is that they’re mainly interfaces for data access. The info is usually somewhere out there on the internet but only accessible via text search or obscure API calls. The beauty of AR with its camera-based object recognition is that the whole world becomes the interface to this data: just look at something to receive more information. Arguably, the same way we did information access since the dawn of time. 3D visualizations You heard me right, I’m also crossing that line here: I think that 3D visualizations could potentially be much more useful and even become mainstream with Augmented Reality. 3D visualizations are shunned in the datavis community, fueled by scores of bad 3D Excel charts and . But if you look at the perceptual science behind them, they might actually not be that terrible (see ). Sure, they suffer from occlusion and perspective distortions, but maybe the additional spatial dimension might make up for that. Especially when we combine them with the most important feature of AR: situatedness in the real world. blatant marketing deception Robert Kosara’s great discussion on his blog Imagine having your awful awful 3D bar chart situated on your coffee table, right in front of you. There’s occlusion (front bars occlude back bars) and distortion (back bars look relative smaller). A 3D visualization of me dragging boxes in SketchUp But in AR, the main problem of 3D vis - the virtuality of it all - is less pronounced. The abstract bars become parts of your environment — it’s clear that the bars in the back look smaller than they actually are (compare them to the physical book next to them). Similarly, occlusion is easily solved by moving around the table, just as you would in the real world. Additional stereo cues (hard to show in a 2D photo) make the virtual bars seem more real than they are. This follows the ideas of , a theory that postulates that our cognition is much more closely coupled to our bodily existence than might be apparent. With AR, you still have your own body available to you to explore data as part of your environment. This is in contrast to Virtual Reality, where you’re completely isolated from both your environment and your body — which can be highly disorienting. Embodied Cognition Sporadic research here and there points at AR 3D vis being a promising direction ( , and there’s a workshop series on ), but I figure that the proliferation of AR toolkits will lead to a lot more results in the near future. Ware and Mitchell created a highly efficient 3D node chart in 2005 Immersive Analytics And yes, there will be the trend of cramming the first AR apps to the brim with flashy 3D stuff. Just like the first new 3D movies insisted on always throwing virtual objects at the audience. But that will subside eventually and make 3D a viable approach in the data visualizer’s toolkit. Floating screens everywhere Finally, AR solves the Mobile Vis dilemma of never enough space by simply letting you create as many arbitrarily-sized and -shaped displays as you need. Free-floating around you, still 2D, but as big as you need them. Just some light network analysis for the holidays. Photo by , augmented by the author. Aidan Meyer Since full AR devices have their physical screens right on your nose, they can create an infinite number of arbitrarily-sized virtual screens, situated in your environment. Head tracking lets you switch between them just as you would with physical screens: simply by turning your head. These virtual screens are interesting when it comes to resolution — since they’re just simulations their resolution can be as finely grained as you need them to be. The physical resolution of the AR headset always stays the same, but when there’s only part of a virtual screen visible (since you’re standing close to one), the full physical resolution is mapped to this part of the virtual screen. This works well, since our eyes are not capable of seeing everything infinitely sharp. We usually move around our environment, coming closer for in-depth inspection. Same with virtual screens — while they might be relatively low-res from afar, you can move as close as you like to see infinitely fine details. There is some ideas in this direction — Isenberg et al. describe “ ” that show different types of visualizations at different viewing distances. Similarly, the static encode multiple layers of values through symbols and brightness, showing different aspects for different viewing distances. And, of course, highly detailed paper-based visualizations inherently allow accessing the data at overview- or detail levels. Hybrid-Image Visualizations Fat Fonts These virtual 2D screens are also a great transitional technology, until all legacy applications have been mapped to an AR-context (if that ever happens). You can think of them as virtual monitors, same as your regular physical ones, just instantaneous, free and 100% eco-friendly. And another advantage, especially when it comes to visualizing sensitive data — be it personal or business — in a public setting: they’re completely invisible to everyone else. The problem of “ ” does not exist in AR, so no one can see what’s on your virtual screen, even though it might fill your whole field-of-view¹. shoulder surfing Shut up and take my money So, how much longer until we can get to work on AR visualizations? The release of tools like ARKit will make powerful AR apps much more common in the next years. Another nice side-effect for Apple is that once display technology becomes mature (and especially thin) enough that they can release their own set of AR glasses (which ), they already have an App Store full of AR-compatible apps. their patents point at From an Apple patent on AR tech (source: ) The Verge Microsoft’s is already available, not very portable and dorky, but almost magical when you put it on. Google has and , which might make a powerful combination for Augmented Reality. We’ll see which of the tech giants will be the first to bring AR to the mainstream. HoloLens Daydream Tango But in any case: smartphones are a transitional technology — we’re actually working towards a world without screens, where everything is a screen. And in this world, all the screen space you could ever want for your data visualizations is instantly available. (This is part 1. Read part 2 on creating silent augmented reality here. ) ❤/👏 If you like this article, please or share it! For more like this, follow me on Medium or follow me on Twitter for general datavis ranting. Notes ¹ Admittedly, shoulder surfing be possible for someone standing so awkwardly behind you that they can read what’s on the inside of your high-resolution glasses. All the spoils would be deserved. might About me Me, datavis-ing AF I’m Dr. Dominikus Baur, an award-winning datavis designer and developer. You can find the projects I’m most proud of and more on my website: https://do.minik.us . You have a fascinating project to work on? You want to turn these ideas into reality? Let me know !

Apple

Instantly

Microsoft

Uber

Can Augmented Reality solve Mobile Visualization?

Last evening while looking into a popular react library, I came across ‘refs’ and even knowing it how it works i wasn’t quite convinced with my understanding so decided to dive more deeper into it and finally sharing my thoughts with you people. According to react docs , refs are used to get reference to a DOM(Document Object Model) node or an instance of a component in a React Application i.e. refs would return the node we are referencing . Lets see it with an example . In the above example for the getting the value of what bob is saying i am using target value of event e .Using refs it could have been done this way Also, we can pass a callback in the refs which can be used to do other cool things. Using refs with callbacks above job could have been done this way When you need refs instead of ID’s ? As we all know , ID’s works on a single element in whole DOM tree thus lets say we want to change the background-color on focus . With ID’s this will happen As Bob comes before Tim and both have the same ID on which background manipulation code runs but only Bob gets angry on focus not Tim. If we use refs we can replace the IDs with the a particular ref name and we should be doing fine. But i would suggest using classes for use-case of this kind as its much better and also refs has its caveats which we would see soon. When it returns a DOM node or a component’s instance? If the ref points to a standard component (DOM node, such as , , etc) then to retrieve the element; you just need to call input select div this.refs.ref. If the ref points to a composite component (a custom component you have created yourself) you need to use the new module like so ReactDOM ReactDOM.findDOMNode(this.refs.ref). When is the value first set ? ref Along with in react , lifecycle methods also exists like render() So , the ref is first set after the first , but before . render() componentDidMount() Use ‘ref’ only if its MUST , otherwise not …why? It hinders in optimized working of Babel inline plugin. Using refs is kinda moving little away the react way of thinking which is once state changes, you re-render the components of your UI that depend on that state. React will take care of making sure only the right bits of the DOM are updated, making the whole thing efficient. You may eventually use refs in a Jquery fashion which is not the goal. all When to use refs ? According to official react docs , Official React Docs Finally , Silver bullets when using refs ! Don’t Inline refs callbacks: I used inline callbacks to show you why it is bad thing to do Arrow and functions in a produce a performance hit by creating a new function on re-render. It should be done something like this bind render() EVERY Also If the callback is defined as an inline function, it will get called twice during updates, first with and then again with the DOM element. React does this to “clean up” the old ref and “set up” the new ref just in case the previous and the next callbacks comes out to be truly different functions. And cleaning up is necessary to avoid stale references (and memory leaks). ref null I also used intentionally which is also not a good practice . string refs According to official react docs , Although string refs are not deprecated, they are considered legacy, and will likely be deprecated at some point in the future. Callback refs are preferred. refs should not be used on functional components because they don’t have instances . Example React Official Docs As MyFunctionalComponent has no instances , above code won’t work as intended. as long as you refer to a DOM element or a class component: BUT **ref** attribute will work inside a functional component React Official Docs Hope you now have a good understanding of along with it use-cases and caveats. If you find it useful do share it with other peeps around you. refs Thanks Let’s continue the conversation on Twitter .

Target

Refs in React : All you need to know !

Slack

tTOP 100 medium writers that wrote about Artificial Intelligence / Machine Learning’ / Deep…

Many people are asking this exact question and after searching the internet for several days, I couldn’t find the answer. So a trip into the EOS Telegram room, and several people helped me. Thanks Fuzzy! This infographic is based on the answers I received plus a fantastic EOS guide on Steemit that was written by : Sandwich https://steemit.com/eos/@sandwich/contributing-to-eos-token-sale-with-myetherwallet-and-contract-inner-workings This guide was the best out there as far as explaining how the EOS public key mapping works, and the deadline to do that is June 3, 2018. There’s a lot of confusion surrounding the tokens, and rightly so. Most people don’t understand what is going on. After spending several full days unraveling this stuff, I think I know how to explain it in a clear way. This mostly applies to people using MyEtherWallet. EOS has setup their own method which is easy to use with . However, not everyone uses Chrome, so there is a need for people to figure out the steps associated with MyEtherWallet. public key mapping of the EOS Chrome and MetaMask Here goes: The EOS blockchain is not alive yet, but it will be after June 2018 (that’s the target date). These new EOS tokens will have specific functionalities, and these will only be live on the EOS blockchain in the future. In order to get these new EOS blockchain tokens that will exist in the future, you need to register your Ethereum wallet address with a public key to EOS. So all the EOS you own now will need to be in that same Ethereum wallet that you registered with EOS. Think of it this way: your Ethereum wallet that holds your EOS tokens is like a house, with an address. You put your EOS tokens inside this house. But the future EOS blockchain has no idea where this house is. You must register your Ethereum wallet address with EOS so that you can get your new EOS tokens that reside on the future EOS blockchain. When the snapshot of all EOS token ownership is taken in the future, your Ethereum wallet that holds EOS will be included in this snapshot as long as you registered it. When this snapshot is taken, you will be able to claim the real live EOS blockchain tokens. But only those who registered their tokens with EOS will be given these new EOS blockchain tokens. So, a page has been set up in order to generate your public-private key pair for the future EOS blockchain. The person who created it states: This will generate a private and public key pair for the EOS chain. The code is not mine. It is forked from the code the EOS team built. The difference is that this works in any browser without the web3 dependency. It will work in any browser and you don’t need any plugins. I’ve also removed everything else except the key generation bits. Go here to generate your public-private key pair for EOS: https://nadejde.github.io/eos-token-sale/ Personally, If I were running EOS, I’d set up a technical helpline on the days before the snapshot, because I bet there will be a significant number of people who don’t understand what needs to happen and why. This stuff is pretty complicated because we are talking about future events, new technology that barely anyone understands and snapshots of a blockchain that doesn’t currently exist. I’m looking forward to what EOS creates since creating smart contracts on Ethereum can be a costly endeavor that occurs accidentally. A friend of mine bought $35 worth of EOS through the crowdsale and ended up accidentally spending $12 in ETH gas fees in the process. The ETH gas fee was set automatically too high and my friend didn’t know she could manually adjust this amount.

Chain

fees

Follow me on Twitter

Can I Send My EOS I Bought on an Exchange To My Ethereum Address Which is Registered To EOS?

Funding

Mosaic

Nike

Wall Street Journal

Yellow

The Future Since 1999

Couple of months ago, we were tackling challenges with scalability of system and were in pursuit of finding right orchestration tools which can help in scaling systems quickly. This draft is outline of things we have tried and learned along the way, most of things might sound familiar to you. A Quick glance of things we came across while building fleets on Kubernetes. We started exploring popular project managed by Google for orchestration management, for DevOps. Starting with two weeks of learning curves, we get our working staging system in (kubernetes in short) and did small working setup to visualize the power of this orchestration framework. Kubernetes kubes Microservices Microservice architectures have been trending because its architectural style aims to tackle the problems of managing modern application by decoupling software solutions into smaller functional services that are expected to fail. This help in quick recovery from failure on smaller functional units in contrast to making recovery from big monolithic software systems. Microservices helps in making your release cycle faster even because you will be focusing on smaller changes in single app instead of pushing code changes in bigger software systems that has multiple dependencies. Containers Microservice architectures got a big tide in 2013 when Docker inc. released Docker technology. gave perfect alternatives to virtual machines and drove software packaging methods in a more developer friendly way. Docker containers are comparatively smaller than virtual machines (VMs). It shares underlying host OS resources, we can spin up hundreds of these small units in order of milliseconds. Their smaller size helps in faster packaging, testing and even deployments because of its portable nature. Docker containers Docker’s container-based platform allows highly portable workloads. Docker containers can run on a developer’s local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments. We started with (GCE) to get things work quickly. We started with a cluster with few , each Node with configuration and in to run stateless components. Google Container Engine 10’s of Nodes 12 vCore 30 GB default pool Before going in depth, we need some (concepts/tools/theory) to onboard into container ship and sail out for cruise. gears We are dividing gears that we need to know into two parts, i.e. first will be and second will focused on . Docker Kubernetes Part — I (Understanding Docker at Dock) Stateless and stateful components In computing, a stateless protocol is a communication protocol in which no information is retained by either sender or receiver. The sender transmits a packet to the receiver and does not expect an acknowledgment of receipt. A UDP connection-oriented session is a stateless connection because neither systems maintains information about the session during its life.In contrast, a protocol that requires keeping of the internal state on the server is known as a stateful protocol. A TCP connection-oriented session is a ‘stateful’ connection because both systems maintain information about the session itself during its life. Understanding containerization concept Container provides operating system-level virtualization through a virtual environment that has its own process and network space, instead of creating a full-fledged virtual machine . This enables the kernel of an operating system to allow the existence of multiple isolated user-space instances, instead of just one. (https://en.wikipedia.org/wiki/Virtual_machine) Writing good Dockerfile for modules Dockerfile is set of instructions used by Docker to build an image. Containers are created using docker images, which can be built either by executing commands manually or automatically through Dockerfile. Docker achieves this by creating safe, LXC (i.e. Linux Containers) based environments for applications called “ ”. docker containers * Writing optimized Dockerfile, understanding order of commands. Each command that we run in Dockerfile is executed as a layer and subsequent command will be build on top of previous layer. Each layer is managed in cache by Docker tool. Docker manages cache itself to reuse layer of previously build Docker images to save time & disk. “one process per container” is frequently a good rule of thumb, it is not a hard and fast rule. Running a single process inside a Docker container Use your best judgment to keep containers as clean and modular as possible. Understanding remote for storing/pushing our locally built docker images, here we have used (GCR) for docker image management. Docker container registry Google container registry Pushing and Pulling Images to GCR ( ) Push images to Docker Cloud ( ) https://cloud.google.com/container-registry/docs/pushing-and-pulling https://docs.docker.com/docker-cloud/builds/push-images/ Part — II ( Understanding Kubernetes in Ocean ) Learning basics of kubernetes & work flow training Kubernetes is an open-source platform for automating deployment, scaling, and operations of application containers across clusters of hosts, providing container-centric infrastructure — Kubernetes.io What are Pods ? How container runs inside a pod? * Pods are the atomic unit on the Kubernetes platform. A Pod is a Kubernetes abstraction that represents a group of one or more application containers (such as Nginx or redis), and some shared resources for those containers. Pod Overview : Images by Kubernetes.io What are Nodes ? (also known as worker or minion) * A Pod always runs inside a Node. A Node is a worker machine in Kubernetes and may be either a virtual or a physical machine, depending on the cluster. Node is controlled by Kubernetes Master. Kubernetes manages scheduling of pods in Nodes running in a cluster. Node Overview : Images by Kubernetes.io What are Deployments ? * We use Deployments to create new resources, or replace existing ones by new ones by means of configuration defined. You can think of it as a supervisor of pods management. What is replication controller and Replica sets ? * A ReplicationController and Replica Sets ensures that a specified number of pod “replicas” are running at any one time. In other words, it makes sure that a pod or homogeneous set of pods are always up and available. If there are too many pods, it will kill some. If there are too few, it will start more. In above file, you can see keyword, this is being managed by replication utility. yaml replicas What is Kubernetes master ? * The controlling services in a Kubernetes cluster are called the master, or control plane, components. For example, master components are responsible for making global decisions about the cluster (e.g., scheduling), and detecting and responding to cluster events (e.g., starting up a new pod when a replication controller’s ‘replicas’ field is unsatisfied). Kubernetes provides a REST API supporting primarily CRUD operations on (mostly) persistent resources, which serve as the hub of its control plane. Kubernetes Ecosystem consists of mutiple components . What are services ? * A Kubernetes Service is an abstraction which defines a logical set of Pods and a policy by which to access them. The set of Pods targeted by a Service is (usually) determined by a Label Selector. Service keep on looking for pods which has specific labels assigned and keep tracks of those pods for request offloading. Service Overview : Images by Kubernetes.io How to debug or get cluster info from command-line ? * is a command line interface for running commands against Kubernetes clusters. kubectl How do we run containers in GCE ? We have number of which manages scaling pods up/down depending upon processing that we need. run containers inside available in a cluster. We need to follow proper versioning of modules to distinguish what is running inside your system and this helps in rollback releases in case of issues in production. deployments Pods Node How about services/APIs we need to expose ? - There comes kubes . We have plenty of APIs we need to expose to outside world. To make it happen, we have couple of kube services exposed using tcp loadbalancer which has been assigned public IP. Internally, these services keeps on doing service discovery using to find pods and attach it to this service, pods having same label will be targeted by a service. Its same concept of how we manage loadbalancer on cloud, attach VMs to a loadbalancer to offload incoming traffic. services label selector Resources running inside Kube ship knows each other very well. Each services/pods can communicate by names assigned to each. Instead of using IPs (private) assigned to each of them, you can use names given as FQDN. It’s a good practise to use names instead of IPs because of dynamic nature of network resource allocation since resources get destroyed and created again in a container lifecycle management. Kube-DNS maintains all list of IPs internally assigned and helps finding resources by names. ? How to decide what resources you should allocate to your pods resources Each container has its own requirements of resources (ie, etc), there comes & in kubes. This helps in keeping your nodes healthy. Many times due to bad limits or not defining limits, your pods can go crazy at utilization. They might eat any of the sources and can lead to node starvation which makes the Node unhealthy and it goes in state due to resource exhaustion. We faced this multiple times at early stage but now we have fine tuned each pods’ resources based on its hunger behaviour. CPU, RAM, disk, network requests limits [Not Ready] How to define Node resources in kubernetes cluster? Depends on container type (which is running inside a ), you can define different . Suppose you have modules named ``` , and ``` , all of them needs ``` ``` each to run, then you can have to run them. In this case, i will allocate following config for my Node pool. pod Node pools Core.X Core.Y Core.Z 2 core, 2 GB Standard Node Pool - Name : Standard Pool — Pool Size : 2 — Node Config: 4 Core, 4 GB — Node Pool Resource : 8 Core, 8 GB — : 6 Core, 6 GB (75 % used Core & RAM) Utilization Now, lets say i have high memory eater modules. let call them ``` ``` , all of them needs ``` ``` each to run, then you need to run them. In this case, i will allocate different config for my Node pool. Mem.X, Mem.Y and Mem.Z 0.5 core, 4 GB High memory Node Pool - Name : HighMem Pool- Pool Size : 2- Node Config : 1 Core, 8 GB- Node Pool Resource : 2 Core, 16 GB- : 1.5 Core, 12 GB (75 % used Core & RAM) Utilization So, based on your Node pool type ( ), you can deploy your pods in different Node pools by using nodeSelector in kubes. https://cloud.google.com/container-engine/docs/node-pools How we monitor Kubernetes ? We can run custom monitoring setup to keep an eye on Nodes. You can run [heapster]( ), ie. responsible for compute resource usage analysis and monitoring of container clusters, hooked with [influxdb]( ) that consumes reporting pushed by heapster and can be visualized in [grafana]( ). https://github.com/kubernetes/heapster https://github.com/influxdata/influxdb https://grafana.com/ Monitoring in Grafana Some configuration in GCE should be taken care, like . If you are running RabbitMQ, Redis or any other message queue as service that needs uptime, better you turn off autoupgrade because kubernetes new version release will schedule all your node for maintenance, however it rolles updates one by one but could affect your production system. Else, if you are fully stateless, you can keep default or skip this warning! Note : autoupgrade kubernetes version https://cloud.google.com/container-engine/docs/node-auto-upgrade gcloud beta container node-pools update <NODEPOOL> — cluster <CLUSTER> — zone <ZONE> — no-enable-autoupgrade Pretty much all above understandings are based on what I learned in last six months of kubernetes running in production. Container management is easy to adapt and lot of new observation is yet to be discovered as we go along the way. Looking at deployments today, Kubernetes is absolutely fantastic in Auto-pilot and doing self-healing jobs itself. We are running more than in cluster together and processing and are pushing more to handle. 1000 pods 10’s of Billions of API calls per month Conclusion : Kubernetes has lifted lot of server management and helped in faster depployments & scaling system. Adaptability is much quicker, most of security and other concerns is being managed by Google. Kubernetes aims to offer a better orchestration management system on top of clustered infrastrcuture. Development on Kubernetes has been happening at storm-speed, and the community of Kubernauts ( https://kubernetes.io/community/ ) has grown bigger. D aemon Blog : https://sunnykrgupta.github.io/managing-fleet-on-kubernetes.html _Posts and writings by Sunny KUMAR_sunnykrgupta.github.io Daemon Blog - Managing fleet on Kubernetes

Flow

Discovery

Managing fleet on Kubernetes

From this series: The example of the mean shift clustering in Poincaré ball space Vectorizing the loops with Numpy (this post) Batches and multithreading In-time compilation with Numba In the previous post I described the working environment and the basic code for clusterize points in the Poincaré ball space. Here I will improve that code transforming two loops to matrix operations. I ended that post with a very promising plot about the speed improvement on a element-wise product of two vectors. So let’s detail it. Vectorized element-wise product Suppose we have two arrays: and we want to obtain as result an array where the elements are the element-wise multiplication of them: We can do it in two ways: with a loop over the elements, or with a vectorized operation. Now: what happens in terms of execution time? I did this calculations with arrays of different dimensions, ranging from 100.000 to 10.000.000. Execution time: relative on the left, absolute on the right. In the right plot you see the execution times of the two operations: the vectorized version is MUCH faster than the looped one. How much faster? You see this in the left plot: the vectorized version is executed in less than 1.3% of the time! Actually when we use the broadcasting capabilities of Numpy like we did in the previous post, under the hood all the operations are automatically vectorized. So using broadcasting not only speed up writing code, it’s also faster the execution of it! In the vectorized element-wise product of this example, in fact i used the Numpy function. np.dot Now, how can apply such strategy to get rid of the loops? Vectorizing the loop in the distance function Let’s begin with the loop in the distance function. From the previous post: We execute this function for each vector of the collection: that’s one of the loops we want to avoid. And we feed the function with all the vectors, one at a time ( ) together with the whole collection ( ): that’s the other loop which we will vectorize. a A If you change the perspective, you can see the collection of vectors as a matrix, and the vectors becomes just rows of the matrix. In this vision, the operations between the vectors becomes operations between the rows of the matrix. For example, 1000 vectors with two components will make a (1000,2) matrix: Example of 1000 vectors with two components Let’s step back to the original formula, and focus at each part of it separately: Distance in Poincaré ball where the double pipe character (like ||a||) means the euclidean . norm For better visualize the following operations, I will simplify the notation by omitting the vectors’ components. So when I will write , you have to remember that that vector has his own components. As consequence, the 2-d matrices which contains vectors will be 3-d matrices, with the vectors’ components along the third, hidden, dimension. v1 The numerator In the numerator of the fraction we have to do a subtraction between vectors, before calculating the squared norm. And we want to vectorize it, i.e. make all the subtractions in a single passage. In other words, we want to obtain this matrix: Matrix of the subtraction between all vector of the collection This will be a symmetric matrix (element (1,2) is equal to element (2,1), etc) and will have all the diagonal elements equal to zero. This means that we actually double the calculations, but that’s the better way of proceed along the next operations. For obtaining such a matrix it’s convenient to leverage on the broadcasting capabilities of Numpy. As example, if we focus for a moment to the first row of it, which is composed by the differences between v1 and all the vectors of the collection , we can obtain it by simply call the subtraction . And given that we have to do the same operation with all the vectors, we have to execute the following operation: S v1-S The subtraction operation. In the code, the first operand is called “trans”, and the second “tiled”. Note that broadcasting has been used. At this point we have to calculate the squared norm of the obtained elements, i.e. we have to square everything in the matrix and then sum up those squares along the vectors’ component axis, which is the omitted third dimension in the matrices, as already said. Speaking in Python/Numpy language, this is the code for obtaining the numerator: Code for obtaining the numerator of the formula The denominator Now the denominator. The two operands between parenthesis can actually be seen as an operation within the same matrix, because we are treating all the vectors at the same time. So beforehand we calculate the squared norm of all the vectors, then subtract the obtained vector from a vector composed by ones. Using broadcasting: Now, to obtain the matrix with all the denominator terms we have to multiply this vector by the transpose of himself: All this is done by the following code: The whole distance formula, and the rest of mean shift Now we have both the numerator and the denominator. All the rest of the operations to get the distances are just element-wise operations made with broadcasting (Thank you Numpy!): The function we built gives as result a matrix with the distances between points in the Poincaré ball: The matrix of the distances between points. Now we have to adapt the main function to use this matrix for running the mean shift algorithm, and at the same time we will get rid of the other loop. Recalling the mean shift algorithm, we have to calculate the weights using a Gaussian kernel. For doing this we can use the same function we already prepared, because thanks to broadcasting it will work for a matrix too, and we will get as result a matrix with the same shape. Then we have to use this matrix to weight all the vectors of the collection. This is a usual matrix product: Matrix multiplication to get the weighted vectors. The first matrix is actually a 2-d matrix, but the 1-d arrays include the vectors’ components hidden dimension. And we have also to normalize each vector by the sum of the weights needed to build it. As example, for having the normalized version of we have to divide it by the sum v1w w(v1,v1) + w(v1,v2) + …. + w(v1, v1000). So we have to sum up the weight matrix along the rows, obtaining an array of summed weights that we will use for divide element-wise the weighted vectors. Here the code needed for all those operations: And that’s all! Now let’s see how much is faster with respect to the looped version. The following plots are made running both the algorithms with collections of two dimensional vectors. Execution time for the mean shift algorithm: relative on the left, absolute on the right. As expected, the vectorized version is much faster then the looped one: with 10.000 2-d vectors it took 844 seconds for execute the looped algorithm, while the vectorized version it’s executed in just 28 seconds. It’s to be said that the execution speed decrease with big dataset. This is an expected behavior, because for N vectors we deal with N² tensor elements. Now: what if we want to make it faster? And what if the number of vectors are so big that they cannot fit in memory? In the next post I will show a batch version of the algorithm, i.e. an algorithm which will process the vectors a bunch at time. And thanks to this, we can execute it in a multiprocess way, where each CPU core will take care of each batch. Stay tuned!

Ball

Speeding up your code (2): vectorizing the loops with Numpy

There’s a new crypto platform on the scene and it’s a blockbuster. Meet NEO. Dubbed the “ ” it’s up over 400% in the last week alone. It rocketed into the top five of , blowing past the veteran Litecoin. Ethereum of China coin market caps Investors are in love. The news media too. A in covered its meteoric rise. The Huff Post gushed “ ” frenzy of stories the pop press Can NEO Become the Biggest Crypto in the World? When you show up in the Huff Post as a crypto, its safe to say you’ve broken through. They’re not exactly ground zero for coin coverage. But is NEO the platform we’ve been waiting for? Will it alter the global financial landscape and ? remake the Matrix forever I dug into the company’s background, website and to find out. white paper Marketing Blitz What set NEO’s coin on fire across the trading exchanges? Turns out it was a clever marketing blitz. NEO isn’t actually new. It’s been around since 2014, with the unfortunate name “Antshares.” Since nobody likes bugs (except me), they wisely at the Microsoft headquarters in Beijing. changed that terrible name to a flurry of fanfare And yes, they picked the name for its reference to the Matrix and because it means “new, young” in Greek. So what exactly do they do? Did they build the world’s greatest iPhone app in a bid for blockchain’s Mozilla moment? Do they have a fantastic new cryptocurrency? Not exactly. In fact, they use a really old basket of currencies. It’s call fiat. From their whitepaper: “NEO will use fiat as its internal currency.” Yeah, I’m talking about dollars, yuan, yen, etc. What the heck is going on here? Turns out a lot. That’s the first of many surprises in their whitepaper, some good, some not so good. The Centralized Decentralized Blockchain? NEO takes a very different approach to blockchain, one that some people will love and others will absolutely hate. The first is that it doesn’t really have a crypto coin. They strive to be a bridge to the old financial system, with smart contracts, certificates, identity and legal compliance. So what’s that’s making everyone so much money? the coin that’s trading on the exchanges That’s the NEO coin, but it’s not the engine that makes their blockchain go, in the way that Ethereum powers the Ethereum network. Instead, the NEO coin is basically a traditional security. It acts like shares in the company that runs the platform. Many of the NEO coins were sold in an earlier ICO and given to early contributors. The rest are held by the company itself, as many or more than 50%: “The remaining 50% of the NEO shares held by the NEO team, will be in the NEO net after the use of NEO smart contract locked for 1 year. 1-year lock-up period, this part of the NEO will be used to maintain the long-term development of Neo.” They even call them “shares” just like a traditionally traded security. That’s about as close to a perfect fit for as I’ve ever seen. But of course, it’s a Chinese company so not subject to the SEC’s rule sets. the Howey Test Like Ethereum, they do use “gas” to run the platform, but it’s fiat that buys gas to execute smart contracts. They’re focused on the classic idea that money needs to be a “stable store of value.” That’s the phrase that centrist, big government, bureaucracy loving economists like Paul Krugman are always going on about to discredit Bitcoin and other cryptos: “It’s not a stable store of value.” Bitcoin and other currencies fluctuate wildly. NEO’s solution to the problem is simple. Don’t use crypto. Just use fiat. Bam! They created a stable store of value by leveraging one that already exists (fiat) and bridged the old and new financial system in a single shot. Using fiat allows traditional financial powerhouses to use the revolutionary new technology of smart contracts, a technology that’s poised to change how we do business all across the world. But what is a smart contract really? It’s “code as law.” Basically it’s a legal document executed as a program. Now you may think it’s impossible to make legal documents into code considering that combined. But really if you think about it, law documents look a lot like code already. They have “ ” statements, loops and variables. some of the bills that come out of Congress are the size of and War and Peace, The Lord of the Rings The Song of Ice and Fire if/then When I used to run my own company I had to deal with contracts and a lot of legal fees. But after watching my lawyer download a template from a legal repository, fill in the blanks and change a few lines I thought, “I can do that too.” Long before I ever heard of a smart contract my engineer’s brain said “that looks like code.” Those fill in the blanks are variables. XYZ Holdings (“Owner”). Owner is then substituted for XYZ Holdings in the rest of the document. A contract is really just a bunch of conditionals. If this happens, then this happens. If so and so is with the company for three years, he or she gets this many shares. If someone violates this provision, this is the penalty. So it’s really no surprise that legal frameworks are turning into actual code. Smart contracts are still somewhat primitive but they’ll explode in complexity and utility in the coming years. Imagine a smart contract that acts as a last will and testament. The coins are self-escrowed in the blockchain and then released at timed intervals to a person’s beneficiaries. My mother has a provision in her will that if I want to take out a big chunk of money, my sister and I both have to agree. Mom thinks my sister or me will run off and buy something crazy without that check on our diabolical power. Geez. Thanks, mom. Way to trust your kids! With a regular paper contract my sister and I could game the system. We might get together and pay the lawyer overseeing the will payouts to look the other way on that provision so we could take out money whenever we wanted. But a smart contract stops that from happening. My sister and I would hold the private keys and we’d both have to turn them at once to release the cash. Contracts like this will become standard in a few years and by the time I’m old enough to kick the bucket a paper will and testament will look like a rotary phone. NEO is looking to level up smart contracts to reduce and replace complex contracts across the business world. They want to make tracking property, like easy and automatic. In fact, blockchains are a better way to track everything from . That’s why the and why . supply chain assets pork chops, to bonds, and peanut butter Nasdaq is spending so much money on blockchain Delaware, the center of the US business world, passed progressive blockchain legislation In essence, NEO wants to dominate the electronic contract of tomorrow. They hope that by innovating hard in this area, they can make it easier for today’s companies to do business on the blockchain. That’s a smart play. For everyone who thinks that cryptocurrency is a bunch of Tulip crazed madness, like and , I’m sorry but you’re dead wrong. You don’t understand that it’s not just Internet nerd money, it’s a whole new wave of financial technology. this idiot this idiot Oh and I’ll put my prediction track record up against anyone’s any day of the week. I’ve been getting paid to predict the future for two decades, as an engineer and sci-fi writer. As a systems architect I’ve helped companies spot trends years in advance. I evangelized Docker containers, deep learning and a software consumption model before most people had any idea about them. As a kid, when my recruiters were telling me to spend all my time learning Solaris I told them to go jump in a lake while I boned up on this new thing called Linux. I pitched an in 2004, about a decade before Nvidia started working on it. artificial intelligence card NEO: The Good, The Bad and the Ugly But it’s not all roses with NEO. There’s some stuff I don’t love in the white paper as well. Beyond smart contracts, they’re looking to unite two competing philosophies in the blockchain universe: on-chain and off-chain transactions. An on-chain transaction is how most money moves in cryptocurrencies today, like Bitcoin and Ethereum. When I send Bitcoin to someone, it broadcasts to the whole network. Miners verify the transaction and once they’re sure I haven’t tried to double spend my coins somewhere, they enshrine it in a block. But on-chain transactions have some serious bottlenecks, as the near constant scaling debate about . Bitcoin’s 1 MB block limit demonstrate Off-chain solutions like propose to dramatically speed up transfers by doing most transactions off the chain and flushing the bundled result of lots of little transactions to the main chain only after a set period of time or in the event of a dispute. That makes the public blockchain the ultimate arbiter of disputes but the off-chain system where most of the day to day action happens. the Lightening Network NEO combines the two concepts into a single platform. They call it a “joint accounting” model. Businesses can conduct transactions off the primary chain, with their own verification methods and then push them to the main chain. This is in sharp contrast to how other platforms, like Ripple and Bitshares, deal with asset transfers. From the white paper: “Ripple, BitShares, NXT, etc all are blockchains of decentralized functionality but without layered design.The blockchain itself acts as the ledger and transaction matcher. In such a blockchain, pending orders, withdraw orders, matching and other operations are recorded on the blockchain.” “Although NEO support the exchange of assets on the chain, the blockchain itself does not provide order book and order matching functionality…through a mechanism called ‘superconducting.’ Under the superconducting transaction, the two parties do not need to host the property to an intermediary (traditional exchange). Users only need send to the exchange an order signed with their private keys. After the exchange matches the buyer and seller orders and broadcast transactions is the transaction complete. From beginning to end, property does not leave the user’s control, putting an end to the traditional moral hazard. Exchange under the superconducting trading mechanism only plays the role of information matching.” On the surface this looks awesome. Businesses can use their own rules to transfer assets. They can even record the result of traditional financial payments and transfers, like using a credit card to buy some screws for a factory. They can then push the result of the sale to the main chain. Unfortunately, that opens the door to all kinds of fraud. With users and/or companies in complete control of trades on their private chains, they can easily double up orders and screw with the system. The white paper proposes to deal with that by an “exchange blacklisting the user as a way of punishment and deterrence.” I’m not sure it will be enough. NEO will have a lot of early challenges to overcome with that system. Not saying that can’t do it, but they’ve opened Pandora’s Box. Legacies Last a Long Time The other thing I don’t love about NEO is the use of centralized certificates to act as IDs on the network. “Individual users and organizations can be certified by the government-authorized CA certification body. The equity registration on the chain chain is electronically signed by a company certified by real name. The transfer and trading of the shares are made by the assignor, the assignee and the company. Before the signing of the three parties, the Company has the obligation to ensure that the transfer and transaction of the shares are in line with the provisions of the Company Law, which are required to obtain the original consent of the original shareholders, the original shareholders’ right of subscription and the limitation of the number of shareholders. The nature of the equity transfer and the transaction is an electronic contract in which the parties are engaged in electronic signatures.” On the surface this is another fantastic idea. By allowing companies to certify their assets, they can do things like issue shares for their company with complete control while easily complying with existing KYC (“Know Your Customer”) laws and anti-money laundering laws. That’s a good thing. It also leverages a system we’ve had in place for a long time, central certificate authorities. The problem is that centralized certificates are not all that trustworthy. They’ve , issued and gotten hacked. We need a to really make certificates robust and resilient to attack. conspired to spy on everyone bogus certificates web of trust To their credit, NEO recognizes this challenge. They plan to “use the blockchain to maintain the certificate revocation list and gradually form a set of digital certificate systems and identity authentication schemes based on blockchain technology.” But legacy technology tends to hang around a lot longer than their designers hoped. Just ask Microsoft. Decisions they’ve made have haunted them for decades. We still have a programs (x86) directory (even though most people haven’t used anything but 64-bit processors in years) and a bloated binary registry. Instead of ensuring that users ran with few privileges on the operating system, they let everyone run as administrator and then tried to retrofit security on top of it. It didn’t work. That’s why Windows is still a magnet for all manner of viruses and other malignant fauna. Even if NEO manages to phase out centrally issued certificates they’ll have to support them for years and years and years, as all the old contracts issued with them will still need to execute. Even worse, by choosing fiat as the primary currency, private chains to verify transactions/prevent fraud and centrally controlled digital certificate authorities for ID, the NEO platform has made an awful lot of compromises to centralization. Call it . It’s not hard to imagine a system where the blockchain is nothing but a database for the current financial system, which is riddled with waste, fraud and massive compliance costs. Instead of uniting the world and with a decentralized Internet, they may end up locking in the Balkanization of the web and ushering in the even faster. centralization with decentralized characteristics locking in open splinternet That kind of sucks. Blockchain tech offers us a way to upgrade the world’s financial and trust systems, not just graft old problems onto the new system while we slap a fresh coat of paint on it. I’m probably being overly harsh here. NEO clearly has a smart group of people behind it. To be clear: I love so much about what they’re doing. They didn’t just do a rebrand, they completely revamped their philosophy and architecture for the modern realities of today’s financial world. While Ethereum and others are firmly fixed on revolutionizing finance, they’re focused on iteration and evolution. In almost every respect they’re absolutely achieving what they set out to achieve, which is to “build a financial system that can bridge the gap to real world assets.” They’ve cleverly found a way to mash up future technology with legacy systems into an elegant hybrid system. In the long run, it may not be the system we need to change the world. But it might just be the system . we need right now ########################################## NOTE: NEO changed their white paper about three days after I posted this, so many of the quotes are now gone. The original link was broken. I have updated the link to the new white paper. The references to fiat are gone in the new paper, as are a few other things, but largely my analysis remains the same, based on my reading of the new paper. They just cleaned it up and made it more focused. ############################################ If you love my work because that’s how we change the future. Help me disconnect from the Matrix and and world. please consider donating on my Patreon page I’ll repay your generosity a hundred fold by focusing all my time and energy on writing, research and delivering amazing content for you ########################################### If you love the crypto space as much as I do, come on over and join , where you can rub elbows with multiple projects in the space. It’s totally free forever. Just come on in and socialize, work together, share code and ideas. Make your ideas better through feedback. Find new friends. Meet your new family. DecStack, the Virtual Co-Working Spot for CryptoCurrency and Decentralized App Projects If anybody from the NEO team wants to come and chat/debate with me or share with other projects, be sure to pop into DecStack.com. You’ll find dozens of projects there. We’re bigger than most project’s Slack now. ############################################ If you enjoyed this article, I’d love it if you could hit the little heart to recommend it to others. After that please feel free email the article off to a friend! Thanks much. ########################################### Photo credit A bit about me: I’m an author, engineer and serial entrepreneur. During the last two decades, I’ve covered a broad range of tech from Linux to virtualization and containers. You can check out my latest novel, an epic Chinese sci-fi civil war saga where China throws off the chains of communism and becomes the world’s first direct democracy, running a highly advanced, artificially intelligent decentralized app platform with no leaders. when you join my Readers Group. Readers have called it “the first serious competition to Neuromancer” and “Detective noir meets Johnny Mnemonic.” You can get a FREE copy of my first novel, The Scorpion Game, You can also check out the based on ideas from the book that outlines how to make that tech a reality right now and you can get in on the alpha. Cicada open source project Lastly, you can , where we discuss all things tech, sci-fi, fantasy and more. join my private Facebook group, the Nanopunk Posthuman Assassins

Litecoin

Mozilla

NVIDIA

Progressive

Techcrunch

Is NEO the One?

I like things very.. simple. I was running my software development business using as the payment processing system. was handling my online payments including customer subscriptions and custom service fees. In this article, I’ll explain how I turned my Stripe account to an online business using our , in under 3 minutes! Don’t believe me? ! Stripe Stripe open-source solution I have proof Subscription-based online business If you own a business, gig, or a side hustle that is providing clients with some sort of service, then you probably have recurring customers. You could be a blogger who provides monthly blogging services, a photographer who is providing portrait services, or a technology business who sells monthly servers, domains, or any other type of subscription-based service. Stripe has already made things a lot simpler. You can easily create payment plans and subscribe customers to them in Stripe. Stripe’s subscription system automatically charges the customer at the end of each billing cycle. It also allows additional fees to each subscription, change price, refund, or even give account credit to the customer at any time during the subscription’s lifetime. If you want to allow your customers to view payment plans, subscribe themselves to plans, approve additional charges, and view invoices, without your handholding, you’d need an online website that integrates with Stripe. A website that automates your subscription-based online business. Automation can get very expensive for businesses! Dreadful solutions There are some existing solutions.. dreadful ones. You could create a new Wordpress website, install WooCommerce plugin, attach your Stripe account to it, and then end up paying a software company thousands of dollars to customize the website so it flawlessly manages your subscriptions and meets your use-cases. Not to mention, you’d also have to hire a designer to make the online shop look presentable. Let’s just say, scaling becomes extremely hard and most likely will force you to change tools completely. It’s a cheap dirty solution. Or, you could of course pay a third-party company, like , a percentage of your revenue to get partial functionality. Pay more, get less, and regret giving a part of your revenue away. This option gets worse as you grow and want to cut your overhead costs. Chargify I haven’t forgotten about a custom website solution. If you have already fell into this rabbit hole, no explanation is needed. If not, then my advice is not trying to reinvent the wheel and build your own custom solution. You’ll end up spending more time building and worrying about your online website rather than the main business. The Solution is a platform that ties to your Stripe account and imports all of your existing Stripe customers, payment plans, subscriptions, and invoices. It will also invite all of your customers to login to a self-service portal to manage their existing subscriptions. You can set it up just in under 3 minutes… That is powerful! ServiceBot Assuming that you already have a Stripe account, the procedure is simple. Three easy steps: 1- Create your ServiceBot website Step one, go to enter your email address, choose a password, and type your business name. Submit. Wait about 15 seconds, and you will be redirected to your new website. https://servicebot.io, ServiceBot — Giving out limit open-beta free instances. September 2017 https://servicebot.io 2- Apply your Stripe API keys Step two, get your and paste them into your ServiceBot website setup page. Stripe API keys ServiceBot initial setup page. ServiceBot requires you to have an Stripe account. 3- Import your Stripe account Step three, login with your email and password, click on Manage System > Stripe settings. Press ‘import’ and all your Stripe account information will be imported to your new online website. You can also choose to notify your customers to login to their new ServiceBot accounts and manage their subscriptions! ServiceBot Stripe Import System. Video Demonstration I also made a video to show you how fast and easy this process really is! How to turn your Stripe account into a full subscription-based online business Conclusion ServiceBot is only an project. It is still running as beta. We are providing everyone with free open-beta ServiceBot websites to gather feedback and improve the software prior to launching ServiceBot 1.0. You can get yours from . eight month old https://servicebot.io Currently we are focusing on our plugin and integration system, and our new NodeJS framework. Don’t forget to checkout our . If you have any questions feel free to contact me . open-source repository directly

Stripe

Turn your Stripe account into an online business

Recently, we implemented a Service Worker for an image-heavy website. Since it’s not a good idea to precache every single image and also runtime caching has its limits, we needed a fallback image. Fortunately, there is an that serves a resolution-independent, accessible SVG for image requests that fail. But after we implemented the SVG, we noticed a couple of issues as you can see in this abstract example: elegant solution We use lazy loading in combination with intrinsic ratios to minimize reflows, which means that the offline image will not fit the reserved space most of the time. Besides, many image wrappers have a placeholder background color that matches the image. This is especially important if a white text overlays a dark image, since we want to make sure the text is legible while the image is loading. So we needed a fallback image that works with any aspect ratio and adapts to the existing background color. After some experimenting, we came up with an improved SVG that looks like this: We used a semi-transparent gray and black as fill-colors, so that any existing placeholder background color is just slightly grayed out and white text on a dark background is still legible. The most important change is the following attribute: <svg preserveAspectRatio="xMidYMid slice" ...> It forces the to scale uniformly from the center and cover the entire SVG viewport. viewBox SVG code Codepen Note: No Service Worker, just the SVG image in the layout from the above. screenshot https://codepen.io/sebastianeberlein/pen/gxGgXe In our Service Worker: Since Firefox version 47 (released in June 2016), the looks like this: . So if you are using this header to check if the request is an image … Side note: Accept header of image requests */* if (request.headers.get('Accept').indexOf('image') !== -1) {// ...} … it will work in Chrome, but not in Firefox. That’s why we switched to file extension matching.

CodePen

Service Worker: One fallback offline image for any aspect ratio

Super

10 Tips For Taming Slack Overload

Developing a single page app is hard. From the very beginning, you’ll need to make many decisions — decisions like picking a framework, setting the folder structure, configuring linter, and many others. Some of those tasks are easier because of the ecosystem of the tools surrounding your favorite framework and web development in general. For example, tools like , and will help you to setup your favorite framework in a few seconds. Create React App Angular CLI Create Choo App Photo by on Jonatan Pie Unsplash Often, you don’t have enough time to even think about the deployment when you start your new project. And at some point, you need your app to be publicly accessible because you want to show it to your client, friends, or to add it to your portfolio while you are looking for your first job. But how can you pick the best place to deploy the app fast? There are many tools for deployment, too. If you go with some new shiny thing, will it scale for production, or will you be forced to make another decision about changing it soon? You can go with pages, but what about the HTTPS you need for service workers? Github Amazon offers something that can scale, a combination of for static website hosting and as a CDN is a cheap but scalable way to deliver your single page app. Although it takes some time to prepare both of those too, even more if you are not familiar with . Simple Storage Service (S3) CloudFront Amazon Web Services There is an easier way, though — introducing , a simple CLI tool that helps you deploy your website or single page app to Amazon S3 and CloudFront with a single command. Scotty.js Beam me up, Scotty The main idea behind Scotty is to deploy your static website or single page app to Amazon ecosystem with a single command. It will deploy your static website, set up CDN with HTTPS, and even copy the website URL to your clipboard in a minute or so, depending on your internet speed and the website/app size. For single page applications, it will also configure redirections, so can work out of the box. pushState Beam me up, Scotty Let’s see it in action with a simple React application. Create React App Before the deployment, we need the app, so let’s create a simple one using Create React App. First, create a sample app by running command from your terminal: create react app create-react-app scotty-cra-example If you do not have the create-react-app command installed, you can get it from NPM here: . https://www.npmjs.com/package/create-react-app Or if you are using NPM v5, you can run Create React App command without installing it globally with the new command: npx npx create-react-app -- scotty-cra-example Learn more about here: . npx https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b Let’s add to demonstrate how pushState support works. To do so, enter your new project and install React Router as a dependency: React Router cd 

npm install Now that everything is installed, let’s add React Router to the project — open “src/App.js” file in your favorite editor and update it to look like a basic example of React Router ( ): https://reacttraining.com/react-router/web/example/basic Now, if you start your app using it should work and look similar to the one from this screenshot: npm start Basic React app with React Router on localhost It’s time to build your app using node script. This will create a folder called “build” in root of your project. npm run build Deploy the app First install Scotty.js from NPM as a global package by running: npm install scottyjs -g Prerequisites for Scotty are: Node.js (v4+) with NPM account AWS AWS credentials — setup tutorial: http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html Then just run following command: scotty --spa --source ./build This command tells Scotty that your app is single page app (SPA) and that the source of your project is in “build” folder. Bucket names are global for all users, which means that you need to come up with a unique name for your app — reusing “scotty-cra-example” will not work. Running this command from your terminal will deploy the app and give you 2 URLs as shown here: First one, which is also added to your clipboard, is an HTTP link to AWS S3. The second one is a CloudFront URL that also supports HTTPS. CDN and HTTPS Scotty will set up your project on CloudFront CDN, which means it will be cached and distributed to different regions to decrease latency. It will also set up HTTPS for free, so your app will be ready to use with service workers or anything else that requires a secure connection. Live app: https://d1reyqfbyftmjg.cloudfront.net How does it work There’s no magic behind Scotty. It uses AWS SDK for Node.js behind the scene. First, it checks if you already have a default region. Unfortunately, AWS doesn’t give us a default region via AWS SDK. Scotty has a small LevelDB database to store that info. If the region doesn’t exist and is not provided, Scotty will ask you to select it. Next step is to create a bucket if bucket name is not provided, Scotty will use the name of your current folder. Keep in mind that bucket names are global for all users, hence, you need to come up with a unique name for your bucket. After bucket is created, Scotty will upload your project to AWS S3 using AWS SDK. If a source flag is not provided, the current folder will be used as a source. As the last step, if your project is a website or a single page app, Scotty will set up CloudFront CDN with HTTPS support. The difference between SPA and website is that Scotty redirects all of the non-existing pages back to index.html, which allows pushState to work out-of-the-box. What are the next steps? Try Scotty and let me know if something can be improved. Happy to receive pull requests as new features and improvements are welcome. Github repository: https://github.com/stojanovic/scottyjs The current idea for Scotty is to stay a small library for AWS only, but that doesn’t mean that it can’t be changed. However, there are a few missing things, such as setting up custom domain names and config file for easier collaboration. Hope you’ll enjoy it 👽

Single command deployment for single page apps

HackerNoon Tech Stories Archive August 13th, 2017

I started my own T-shirt company in 24 hours and made $0

@stervy
Stephen Cognetta

You should use SSM Parameter Store over Lambda env variables

@theburningmonk
Yan Cui

Can Augmented Reality solve Mobile Visualization?

@dominikus
Dominikus Baur

Refs in React : All you need to know !

@solodynamo
Ankit Singh (@solodynamo)

tTOP 100 medium writers that wrote about Artificial Intelligence / Machine Learning’ / Deep…

@baditaflorin
Florin Badita

Can I Send My EOS I Bought on an Exchange To My Ethereum Address Which is Registered To EOS?

@crypto-stella
Crypto Stella

The Future Since 1999

@dsearls
Doc Searls

Managing fleet on Kubernetes

@sunnykrgupta
Sunny Gupta

Speeding up your code (2): vectorizing the loops with Numpy

@vincenzo.lavorini
Vincenzo Lavorini

Is NEO the One?

@dan.jeffries
Daniel Jeffries

Turn your Stripe account into an online business

@darafsheh
Shar Darafsheh

Service Worker: One fallback offline image for any aspect ratio

@sebastian.eberlein
Sebastian Eberlein

10 Tips For Taming Slack Overload

@johnpcutler
John Cutler

Single command deployment for single page apps

@slobodan
Slobodan Stojanović

HackerNoon Tech Stories Archive August 13th, 2017

@stervyStephen Cognetta

@theburningmonkYan Cui

@dominikusDominikus Baur

@solodynamoAnkit Singh (@solodynamo)

@baditaflorinFlorin Badita

@crypto-stellaCrypto Stella

@dsearlsDoc Searls

@sunnykrguptaSunny Gupta

@vincenzo.lavoriniVincenzo Lavorini

@dan.jeffriesDaniel Jeffries

@darafshehShar Darafsheh

@sebastian.eberleinSebastian Eberlein

@johnpcutlerJohn Cutler

@slobodanSlobodan Stojanović