Linters may not be as powerful as compilers — since they can’t add new language features — but they’re pretty good at features. And sometimes, taking away features can be just as powerful as adding them. taking away This observation is especially true when we talk about . Encapsulation is about , aka information. A lot of encapsulation features are implemented at the language level, such as function scoping and module scoping. But when we want even more encapsulation than what the language provides, linters are a good fit to take over. encapsulation information hiding taking away Let’s look at some examples where ESLint provides us with encapsulation even while ES6 provides none. Encapsulating the Browser API If you need to support server-side rendering, then you’ll have to make sure that your code can run in a server environment, where there won’t be any browser-specific global variables like , , etc. Thankfully, ESLint allows us to configure the global variables for a given file: window location ReactDOM.render(  <App />,  document.getElementById('root')); // flagged by linter

/* eslint-env browser */ This way, we can the browser API from all modules, except the specific modules that need them. We can do the same for ! hide other environments too Encapsulating Modules Let’s say that we want to centralize all requests in our codebase to one file called . We’re probably using a single networking client for this, like for example. We can enforce this by making sure that no one in the codebase can import Axios except for our file. network api.js Axios api.js We’ll use the lint rule to disallow other modules from importing Axios by adding this to our : no-restricted-modules .eslintrc {    "no-restricted-modules": ["error", "axios"]} and then disable it just for our file: api.js This way, we can networking functionality from all modules, except the specific modules we whitelist. hide Encapsulating Classes Let’s say we want a private method in our class. Unfortunately, there’s no keyword for us to use for enforcing this rule, but we can use ESLint’s rule to a similar effect: Javascript private no-underscore-dangle class MyClass {_myPrivateMethod() {} myPublicMethod() {}} const instance = MyClass()instance._myPrivateMethod(); // flagged by linter Lint Rules are Traffic cones All of the above encapsulations are easy to break. Static analysis tools like linters can’t protect against dynamic language features like , or , and that’s fine. Lint rules are more like traffic cones than concrete walls. require('axios') instance['_myPrivateMethod']() The idea isn’t to guard against willful violations of these rules. It’s to align the path of least resistance with best practices, and that’s usually good enough. is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Facebook

Using ESLint for Encapsulation

Building applications using is covered well in several publications. In this post my attempt is to cover few problems which do not get as much attention and discuss solution of each. Paying early attention to these areas would help you improve productivity, quality and build a flexible application. I will also show that it can save 25% or more in cost. These lessons are learnt by working on an open-source platform and working with few customers. microservices If you are building microservice based , you would divide application in several microservices and use variety of technology stacks. An application may have 5–500 microservices depending on complexity. You may be using a mix of Java, .Net, Python, NodeJS, GO etc. based technology stacks. that is often missed, how is a developer going to use these services in development environment for testing. Developers are the most productive when they are using IDE of choice on personal machines. It helps them write and debug code faster. It is impractical to run several services on personal machines for debugging and unit testing. that is highly debated what “should and should not” constitute shared code. People lean towards un-sharing. is creating reusable services which can acquire personality of slightly varying services through meta-data or scripting. is not critical for server side developers but for UI developers. It deals with how to slice a large UI into smaller pieces, develop each independently and automatically put them together at runtime. application One important consideration Another issue The third important consideration The fourth issue In the following sections we will get into details of these four areas and discuss how to solve them. Connect to Any Microservice at Will from Developer’s Machine In operational environment, you would probably have all microservices running on private or public cloud somewhere. But developers can’t reach to them due to network security reasons. Even if developers can create a secure tunnel to these services, it is lot of work and distraction from daily development. Break developers concentration and they have to “eat frog” before they start rolling. How can a developer connect to services in cloud from his or her machine? You probably guessed it — “ ”. If you have one, sweet! If not then probably you would build it someday to expose your services to outside world. Why not do it now so your own developers become consumer of APIs. It would also help in abstraction, understanding of services and standardization. Having a gateway is not enough but it is the first required step. we need a gateway to services In this case, the goal of a gateway is to provide close to deployment environment to developers. There are few more things you need to consider to create a true deployment environment on developer’s personal machine. In order to develop and debug, developers run few services (generally 2–3) locally and like to connect to rest in cloud. Thus, it is an environment that is a mix of services on developers’ machines and in cloud. It is achieved by changing IP addresses of endpoints of services, pulling few code repositories or containers. If you visualize it, you are creating an environment which is a slight variation of centrally available environment to everyone. What is the best way to achieve it? This can be achieved if you design a light gateway which is lightweight and configurable, ideally through UI. Through UI developers can change IP addresses of services. If it simple enough developers can deployit on local machines to mediate between local and cloud services. This resulting structure is shown in the following diagram. Connecting Local and Remote Microservices using Gateway You would find several use-cases of reusing above design with gateway creatively. Let us take one more example. If you are developing an application which uses single sign-on (SSO), you can use operational environment to acquire access-token and use it in hybrid environment where you are running services on local machine and remote cloud. I intend to cover this as a separate blog later. Code Sharing Among Microservices One of the benefits of microservice architecture is that changes in one service does not cause a ripple effect. Therefore, the idea is to make them completely independent of code changes in one to other. But it does not mean that you should not share code. It probably means that you need a proper version management for the shared code. The shared code can evolve. But a service using it can decide to migrate to the newer version or not. In fact, this is how we use the open source code. You will be using several open source libraries in your microservices. There is no reason you can’t treat your own shared code in the same way. You can never go wrong by sharing. Let us say you have 10 services which could have used “X” common code. The worst case when you don’t share, all have 10X extra code. You begin by sharing the version 1 of “X”. “X” moved to version 2. Only 3 services would have moved to “X 2.0”. You would still have lots of code sharing. You can also have multiple layers of shared libraries. Some services may bypass higher level layers if they don’t need them. The following diagram shows layering of code with and without code sharing. If you properly plan code sharing, it is a big winner. Depiction of Code Sharing and Not Sharing Options You can look for sharing code in these areas: Few examples utilities are string processing function, common functions using regex, common domain specific utilities, generic data structures, data structures specific to domain but reusable as templates, data validation code, file read-write code etc. Utility functions — — Consider writing CRUD, query, pagination as generic libraries which can take schema as input. You can standardize on few base attributes across all entities such as id, name, friendly name, version, state flags etc. Using schema file you can define meta properties of attributes such as uniqueness, type etc. Common code can implement logic based on metadata. Database API — Stateless functions or methods that receive input, processes and returns output. These are algorithms that can be shared across services. Few example are sorting, decision trees, generic rules. Common Algorithms — Common logging wrapper if you want to keep the option to plug-in different open source libraries. Logging — Data validation for security, checking privileges etc are example of common security functions. Security Related API Rule of thumb — ask around, “Is there a code I can reuse or contribute to?” It is the open source model and you will not go wrong. Configurable and Programmable Services There are many opportunities in computer software where something is a variation of something else. In case of microservices too, you can find a common denominator and pull it out as a generic code which can be called “template-service”. If you follow a data driven design then it can morph into a special case using meta-data and some pluggable scripts. For example, let us say you have a service called . It will probably save data in database. There is a that is also saving data in the same data base. You can pull out common denominator code as which will take schemas and pluggable code as input. Another option is to deploy as three services: i) Order Service, ii) Customer Service and iii) Persistence Service. A data driven design of will be easier if you are using NoSQL DB than RDBMS. But you can do it in each case. You may find other benefits of such a design. For example, in this particular case, it separates the application logic from database logic; DB experts can optimize it independent of business service. This is one illustration and may not be quite possible in your case. But the overall idea is that if you can pull out infrastructure like code from multiple services into template-services then give it serious consideration. It will not be obvious. Once you get used to metadata and scripting programming model, you will start seeing several such opportunities. I intend to cover this in much greater details in a separate post. Order Service Shipment Service Persistence Service Persistence Service Template Microservice — Programmable using Metadata and Plug-ins WEB Tier and Decomposing UI into Smaller Pieces It is prudent to develop multi-device WEB UI that is pure HTML, JavaScript and CSS and does not use any server side libraries for rendering. It is very likely that you are already doing it. On server side, it simply requires to serve a barebone HTML page with required JS, CSS. UI connects to services using a secure tier or gateway. In case of a large UI, you can divide it into functional components and let teams develop them independently. Let us call each functional component as . You can develop each micro-application as a HTML page and yet avoid reload when the integrated application is deployed. “micro-application” Let us look at the HTML page served for a micro-application by the server. It would have the following content. <html> <header> load open source css load common css (common across all micro-applications) load css specific to micro-application </header> <body> Mostly empty, rendered using templates </body> load open source JS load common JS (common across all micro-applications) load JS specific to micro-application </html> You will notice that parts which change are micro-application specific CSS, JS and corresponding HTML templates. In integrated environment, previous micro-application code can be unloaded and new micr0-application code can be loaded without page refresh. A micro-application can be represented by URL which may have its name as path in the URL. Using a proper WEB server design, you can use path to plug in specific CSS, JS in barebone HTML page on the server side. For clarity and modularity, you can organize micro-application specific JS, CSS, HTML templates in separate directories. This decomposes your application on the UI side quite similar to the way that microservices do on the server side. Decomposition of a Large UI as Micro-Applications Business Benefits The above mentioned considerations lead to significant business benefits. Let us say a developer spends 4 hours a week struggling to connect to services. In a 6 month project with 10 developers it will mean 4 person months i.e. roughly 7%. Add to it frustrated developers working at lower productivity and quality, it can top 10%. If you have a solid plan for code sharing among microservices, it will lead to additional saving. Writing data driven, programmable services and be able to adopt them to some degree of variation will provide flexibility and save time-money in a short as well as long run. UI code can get spaghetti very easily as its volume grows. You can avoid it by breaking UI into smaller modules (or micro-applications in traditional WEB app sense). Let us say each of these contributes to 5% saving. All this adds up to 25%. You can use it towards building high value features, better UX or team rewards. The flexible and modular code base also opens up the door for innovations. Future Posts I intend to cover following topics more in details in separate posts. 1. Lightweight Gateway Design 2. Data Derive, Programmable Template-Service 3. UI Decomposition as Micro Applications 4. Developing Secure Microservices

Stacks

Development of Microservices - Problems and Solutions

I built the web-site where you can explore the Stack Overflow questions referenced in the source code in . Check it out in TL;DR Github http://sociting.biz I am a big fan of Cloud Platform, especially I love its data warehouse implementation called BigQuery. In summer of 2016 Github and Google made the open-source data available for everyone in BigQuery, here are the mind boggling numbers: Motivation Google This 3TB+ dataset comprises the largest released source of GitHub activity to date. It contains a full snapshot of the content of more than 2.8 million open source GitHub repositories including more than 145 million unique commits, over 2 billion different file paths, and the contents of the latest revision for 163 million files, all of which are searchable with regular expressions. I have since then never tired of exploring these data, revealing interesting patterns or extreme samples and publishing about my findings.In December of 2016 Google team has woken up my “researcher within” again — they’ve added Stack Overflow’s history of questions and answers to the collection of public datasets on BigQuery. In practice that means that the most popular programming chat in the world is now can be analyzed with the power of Google Cloud Platform, for example one can run the on the Stack Overflow data and find out that Python developers post the lowest percent of negative comments overall! What excites me the most though is the ability to join the Stack Overflow data with other . For example one can try to find out whether the weather can affect the probability of a Stack Overflow question to be answered by using the data from am actually going to conduct this research soon).In the to the Stack Overflow data availability provided the sample of joining Github and Stack Overflow data to find out which are the most referenced Stack Overflow questions in the GitHub code — specifically, Javascript. It gripped my attention because I noticed a couple of limitations: * The query searches only for stackoverflow.com/questions/([0–9]+)/ pattern in the source code. However, there are alternative forms of referencing questions : it could a short form stackoverflow.com/q/([0–9]+)/ and it could be the direct reference to one of the answers, like stackoverflow.com/answers/([0–9]+)/* The query deals only with JavaScript sources, but there are plenty of other programming languages. articles sentiment analysis publicly available data sets NOAA dataset (I introduction Felipe Hoffa So, I set out to build the catalog of the stack overflow questions referenced in the GitHub sources for popular programming languages. Finding lines of code in Github Sources that have references to StackOverflow questions or answers. table that keeps contents for the top languages from the top repos was kindly provided by Felipe Hoffa Getting the data Step 1 contents_top_repos_top_langs The result has been saved in the new table called which contains the rows like so_ref_top_repos_top_langs Join the result with the StackOverflow data. The query should handle both of the questions id’s and answers id’s extracted from the source code Step 2 The result contains the rows the look like There were roughly 31K records like this one, the next question was on how to visualize them. First of all I moved the resulting data to the SQLite database by creating separate table for each programming language. Then I built the [web-site]( ) that allows to navigate through the data by switching between the languages and jump to the Github source code to check how the information from the questions/answers was applied in the specific scenarios. I also caught this opportunity to play with ASP.NET Core and implement the web-site on my Macbook Pro, without Windows being involved. The resulting application uses the cross platform ASP MVC Web API on the back end and react+redux on the front end. The source code is fully available in the . Building the web-site http://sociting.biz Github repo is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Google

One More Analysis of GitHub and StackOverflow Data with Google BigQuery

I don’t usually think of algorithms in my free time. I rather workout or do anything that takes my mind off of software for a while — it’s important to maintain your productivity they say. But every now and then, I download a new app on my phone and I get interested in knowing how the app works and what are the algorithms behind it (it’s a good exercise for any software engineer btw). engineering I recently moved to San Francisco for a job here. I share an apartment with 2 roommates and we use an app (which I won’t name since they didn’t pay me to advertise their product) to help us split our house expenses equally. And as you can probably guess, I tried determining how it was implemented. Max Flow Theorem For those of you unfamiliar with this , I suggest you take a quick look at its wikipedia page. If you’re in computer science or any related major, you have probably struggled already in one of your algorithms design classes that used this theorem to solve any kind of problem. You probably even asked yourself “Am i really going to use this in real life?”. algorithm Without further ado, here’s a cool way I think someone can implement an expense sharing app. The Big Kahuna Suppose we have three roommates: John, Kate and Ann. John paid a total of $40 in expenses, while Kate and Ann paid $10 each (easy example to demonstrate the usefulness of Max Flow in this scenario). How would you split the money equally? We would need to build a Max-Flow graph by following these steps: 1- Calculate the total amount paid. Amount = 40 + 10 + 10 = $60 2- Calculate how much money each person should have paid: DuePerPerson = Amount / # people = 60 / 3 = $20 3- Calculate the difference between the amount paid by each person and the DuePerPerson diff (John) = 40–20 = 20 diff (Kate) = 10–20 = -10 diff(Ann) = 10–20 = -10 4- Create a node in your graph for each person 5- Create an edge with capacity equal to ∞ that connects each person to the other people in the graph each edge has capacity ∞ in this graph 6- Now, for each calculated before, if the value was negative, it means the person still needs to reimburse someone: we add an inward edge to the user with the capacity equal to | | (absolute value of ). This represents an inward flow of money into the network. Else, we create an outward edge with capacity equal to . As you can guess, this will represent the outward flow of money from the graph. That way we make sure each person pays the right amount, and each person gets paid what they are owed. diff diff diff diff 20, 10, 10 represent the capacities of the 3 edges Applying the max flow algorithm will result in multiple paths that represent the flow of money from one user to another, which is equivalent to dividing the expenses equally between the users. 10 / inf means there is a flow of 10 on the edge of capacity equal to infinity Cool eh? Next time you learn an algorithm, don’t ask yourself “Am i really going to use this in real life?”. The answer is Yes. Good Day.

Flow

The Graph

Max Flow Algorithm in real life

Square has a library that most people don’t know about. It’s called . Not a very descriptive name, and there isn’t all that much info about it on the page either. coordinators Github Simple lifecycle for your MVWhatever on . No kidding. Android And some example code: class ExampleCoordinator extends Coordinator { @Override public void attach(View view) {// Attach listeners, load state, whatever.} @Override public void detach(View view) {// Unbind listeners, save state, go nuts.}} And that you can install a to any : Coordinator View // Bind a Coordinator to a View.Coordinators.bind(view, coordinatorProvider); It really doesn’t say anything about what it is, what it does, and how it should be used, right? Well, in order to understand this problem, we must walk through the evolution of custom viewgroups, because this is, apparently, the next step. The evolution of displaying screens on Android (Feel free to skip forward to the good stuff if the Activity/Fragment stuff bores you!) Activity Everybody knows Activities. They supposedly represent a single screen in the app, and is technically an “entry point” according to specific intent filters you can define. In order to start a new Activity, you use an , like . Intent activity.startActivity(activity, OtherActivity.class) They also cannot be nested. Well okay, that’s not entirely true, there’s and , but they’re quite deprecated since API Level 11. We may as well pretend they don’t exist. LocalActivityManager ActivityGroup Activities display view groups with . People generally assumed that it only shows one particular type of viewgroup specified with its layout id ( ), and then if you ever needed a different screen, you’d just make a new Activity instead. setContentView() R.layout.activity_main Then once you had to put two different screens on the same “page”, all hell broke loose. Fragments Fragment/Activity lifecycle from by Steve Pomeroy https://github.com/xxv/android-lifecycle Fragments are, well, “fragments” of a screen. They display a custom viewgroup, and are managed by the inside the Activity. The is associated with a , which is associated with the “host Activity”. technically FragmentManager Fragment FragmentController They were designed primarily so that you can create “sub-screens” that function like “sub-activities”, inheriting all important lifecycle callbacks such as , , , and even more importantly . onCreate() onActivityResult() onPermissionResult() onSaveInstanceState(Bundle bundle); They also add their own set of lifecycle callbacks, such as , , , , and . onAttach() onCreateView() onActivityCreated() onDestroyView() onDetach() You can create Fragments with . getSupportFragmentManager().beginTransaction().add(R.id.container, new MyFragment()).commit(); Most of the time though, you just need to access the Activity you’re bound to, (typically done with ), and the pairs and . somehow onAttach() onCreateView() onDestroyView() That, and now with all the additional complexity, you can nest a Fragment inside a Fragment, by — which can sometimes cause confusion in whether you need or . using the Fragment’s [getChildFragmentManager()](http://stackoverflow.com/a/13391359/2413303) getFragmentManager() getChildFragmentManager() One may ask, do we really NEED all these lifecycle callbacks in our “subview” inside the Activity? We may also ask, if we can have “subviews” in our Activity, then why create multiple Activities in the first place? Custom Viewgroups You know what Activities and Fragments have in common? They display that are already inherently nestable ( and ), they’re all declared in XML, and they also have some nice callbacks. Viewgroups ViewGroup View Makes you wonder why we were trying to use them to show different screens in the first place, when you can just swap out views and get the same result. We can extend the viewgroup of our choice ( , , , , etc.) and use the new custom viewgroup of our choice as whatever we’re inheriting from. DrawerLayout RelativeLayout FrameLayout LinearLayout Because we use layout inflation using the to inflate the custom viewgroup, the views we bind in or are always guaranteed to exist in . R.layout.custom_viewgroup @OnClick @BindView onFinishInflate() So in essence, we have something akin to , and callbacks out of the box. onViewCreated() onStart() onStop() Instead of , we can easily just , or . getSupportFragmentManager().beginTransaction().blah().commit() inflate addView removeView But even though we’ve made a subscreen that’s no longer directly bound to a messy blob of unnecessary callbacks, orchestrated by the arcane — there’s one thing that might still bother us. FragmentManagerImpl The custom viewgroup is created via inflation, and it’s not a POJO. It has 4 constructors, and needs to extend an Android-specific class to work. Coordinators In order to detach ourselves from the confines of a Custom Viewgroup, we can move all “view controller” logic outside of the viewgroup itself, and attach it as a tag. This is how it works: So what happens is that you can create a Coordinator, which can be pretty much any POJO class, and can be attached to any custom viewgroup without having to extend it. And with Coordinators, you receive a callback for and . in place of the original viewgroup’s and callbacks. attach(View) detach(View) onAttachedToWindow() onDetachedFromWindow() This Coordinator instance is then associated with the ViewGroup by storing it as a . This way, the coordinator can be obtained as , which is of course provided by class. tag Coordinator coordinator = (Coordinator)getTag(R.id.coordinator) Coordinators What is the benefit of this? Now that our class is a POJO, we can actually inject this class directly with Dagger, without having to specify a method in the Component. void inject(MyCustomViewGroup group); With that, we’ve obtained the following benefits: we do not need to inherit from a viewgroup and define 4 constructors in order to define our own “view controller” logic we can directly inject our newly made Coordinator directly from Dagger, without need for void inject(MyCoordinator coordinator) we no longer need a to create an instance of the “view”, we can just create a Coordinator instead Context Conclusion Personally, I like the direction that is taking. I’m not entirely sure if the and callbacks themselves are truly sufficient, but defining an and method of our own in our own class, then associating it with a isn’t exactly difficult either. Coordinators onAttachedToWindow() onDetachedFromWindow() attach(View) detach(View) tag In return, we receive a POJO view controller that can be directly created and injected via Dagger, without need of creating 4 constructors and hard-wiring the custom viewgroup in its own XML file. The new Coordinator approach works especially well if the navigation logic is detached from Activities/Fragments, and is moved to the Presenter layer. It makes for much cleaner code — application state transition isn’t something that the views should manage, after all. I took coordinators on a test drive in . https://github.com/Zhuinden/simple-stack/tree/master/simple-stack-example-mvp

Coordinators: solving a problem you didn’t even know you had

We frequently build caches to improve actual and perceived application performance for our end users. This article describes how a TS language feature, generics, can help us build a cache. The first thing you need to do when building a cache (and really any kind of generic service utility) is to define its public interface. At its core, a typical cache has some way to store and retrieve values. A more fully functional cache will also let you inspect the cache, clear one or more items from the cache and other goodness, but for he sake of this article, we’ll say that we just have two things to do: and . Put Get Let’s consider Put. When we put an item into the cache, we often want to assign some a lifetime for that item. This is the window in time that the item is valid*****. We are eventually going to retrieve items from the cache and in order to do that, we need some way to uniquely identify that cached item. We’ll call that unique identity the item’s . Put it all together and we have a workable function signature for Put: key public Put(key: string, data: any, lifetimeInMilliseconds: number): void Things are bit more interesting with . As you can, when we put the data into the cache, it’s an “any” time. This is fine since the cache is indifferent to the type of data it’s caching (at least in the abstract). If we took it no further than this, we’d have a Get signature like this: Get public Get(key: string): any We can do better in TypeScript using generics. We can instead decorate Get() with a generic type and tell it the actual data type we expect to retrieve. It looks like this: public Get<T>(key:string) : T This is telling the TypeScript compiler that we’re going to issue a against the cache. However, we’re also going to tell it that we already know/expect the data type of the response: “T”. Get Imagine if we have cached two objects, one named “UserProfile” and the othe named “FavoriteItem”. With generics, I do this: TypeScript const cachedProfile = cacheService.Get<UserProfile>(“someKey”);const cachedFaves = cacheService.Get<FavoriteItem[]>(“someOhterKey”); Since we’re now telling Get that we expect a UserProfile in the first case and an array of FavoriteItem in the other, the corresponding const vars are now strongly typed. This is a very basic example and generics can go a lot further. Consider, for example, that JS objects are actually complicated things to work with generically. In the real cache utility I wrote, my cacheable objects are simple — they just hold data. They don’t have their own functions or contain other nested objects. Hence, I can safely serialize and deserialize them using JSON.stringify() and JSON.parse(). This isn’t good enough for more complex objects. Using generics, we could tell TypeScript that we are only allowed to work with <T>’s that implement a smart Serialize() and Deserialize() method. The code would look like this: public Put<T extends Serializable>(key: string, data: T, lifetime: number);public Get<T extends Serializable>(key: string): T; At runtime, the TS compiler won’t let us use this particular cache service on objects unless they implement an interface named “Serializable.” If you’d like to learn more about this, check out this previous article I wrote: . https://medium.com/@pagalvin/implement-binary-search-in-typescript-using-generics-with-useful-refactorings-a4bcda932d7#.tv0of7jdo Generics give us a great for telling the TypeScript compiler what we expect the data to look like at runtime. This, in turns, gives it the information it needs in order to provide great intellisense and other dev-time goodness to help us be more productive. tool (*) Using time to live is just one of many options. This quote is apt: There are only two hard things in Computer Science: cache invalidation and naming things. — Phil Karlton </end> is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Use TypeScript Generics to Build a Simple Yet Strongly Typed Cache Utility

Monolith waiting to be demolished Moving from a monolith to a service oriented architecture is one of the architectural changes that we hear more often in web development. While some people believe this is what you should be doing if you want to modernize your application, others believe that if the monolith is working, is better not to touch it. I tried breaking a part of a monolith and I failed. This is what I learnt: Focus on your main goal Your main goal is refactoring your current application so that you can move to a service oriented architecture. It’s possible that the new architecture allows your app to do new functionality that before would have been really complex and you might be tempted to do it. Just don’t. Breaking a monolith is not an easy task and the less distractions you have the better. You will have to deal not only with the use cases that you already had, but also with the complexity of managing interaction between service, testing the integration between them, etc. Take an incremental approach It is really tempting to create a new service from scratch, in its own repository, designing an awesome REST API and define how all the interactions with your monolith are going to look like. This is so much fun, you are working on an ideal service, perhaps using a new technology and everything seems great, but this will cause you a lot of trouble. Here is why: Your existing application is evolving and your ideal service functionalities might get outdated. Most likely you are not going to be able to do a code freeze. You don’t have a quick feedback from the users using your application, which means you don’t know whether or not what you have implemented works how they want. Instead of doing this building from scratch, you should try to isolate the domain that you want to later on extract into its own service. Find the spots where the responsibilities of the domains that you don’t own are leaking into yours, as well as how your domain is leaking into other domains. Try to put a clean border in those places, making sure that the separation of concerns between domains are clear within the same app. Talk to the stakeholders I’ve found myself learning a lot from talking to the stakeholders in order to understand what are the needs of the experts on the domain I am trying to extract. For example, while it might come natural for you think that you have a domain leak into your domain and you just want to get rid of it, you might not realize that there is an actually need for that to exist. Propose your changes to the stakeholders, listen to them and then make the changes. Don’t overestimate the power of talking to the people who are using your system on a daily basis and are the real experts of what it should be doing once its divorced from the monolith. Conclusions If you are trying to break a monolith, or at least a part of it, remember that this is usually a complex task and you should protect yourself from adding new features while you are doing it. Isolating your domain incrementally instead of using a design upfront approach will help you to have quick feedback and finding real problems that you would have not imagined if you were building your ideal service in parallel. Lastly, talk to your stakeholders. Those are the ones who truly understand the domain you are trying to extract and will be really useful when doing some design decisions.

What I learnt while trying to extract a domain from a monolith

Achievements and trophies are outdated When the Xbox 360 launched in 2005 it introduced a mechanic that would soon become one of the most important features of gaming ecosystems. I’m talking about achievements. Achievements are a sort of digital reward you receive for completing certain objectives in games. These may vary from beating the , to beating it under certain circumstances or doing side activities like collecting stuff, playing a big amount of matches,etc. Once you complete one of these you get an achievement (or trophy on or badge on Steam): game Playstation Achievements are important for many reasons. On one hand it allows the developer to lead the player into exploring different elements from a game they might have otherwise skipped. For example, it might reward the player with an achievement for using a concrete gun a certain number of times, or for doing a side activity of the game not related to the main story. On the other hand it adds long-lasting value to a game, since players might not feel that they’ve beaten the game until they have earned all of its achievements. This contributes to gamers not reselling their games, since the later they try to do so the less money they’ll get for them. This, in return, means more money for the publishers and for the manufacturer as well since they sell more first hand games. Last but not least, it creates a social layer on top of gaming ecosystems that makes gamers think twice about buying a game for a different system or changing systems altogether. The social layer comes to be because you start competing with friends on who has more achievements on a system. This makes changing to a different gaming ecosystem costly in the sense that you’ll lose all those hard-earned trophies. For this reason, many people buy a game for system X even if it runs better or has more features in system Y, just because they want to contribute to their achievements. For the same reason, they might stick with a console brand in a generational change. Console manufacturers benefit a lot from this. Let’s now analyse how achievements work nowadays in Xbox One, PS4 and Steam: Xbox One has by far the most fleshed out achievement program, although it can still learn some tricks from the other ecosystems. The way it works is that every achievement is worth X amount of points and players have a Gamerscore, which sums up all the points your achievements are worth. Every game has 1.000 Gamerscore points worth of achievements and DLCs have 250 Gamerscore points. Once you unlock an achievement you get a notification on the screen: Xbox One Achievement notification Some games have pre-set images for each achievement and other capture a screenshot of the moment you unlocked it. In the “Achievements” section of the Xbox you can see all your achievements for every game, compare it to your friends’ and see how much you’ve progressed on every certain one: Something additional achievements have on Xbox is that each game has a specific set of metrics that compare how you are doing against your friends. In Gears of War 4, for example, it show how many headshots you’ve done, how many collectables you’ve found, how long you’ve played and other metrics and tells you how you rank in all of those against your friends. This again, is a way of keeping someone hooked to a game and increasing its replay value. PS4 has a slightly different system. Achievements are called trophies and are divided in 4 categories: bronze, silver, gold, platinum. There’s only one platinum trophy per game, which is awarded once you’ve earned all other trophies. Some games don’t have a platinum trophy if it’s considered too easy to unlock all other trophies. From left to right: bronze, silver, gold, platinum (duh!) Instead of having a Gamerscore players are assigned levels based on how many trophies they’ve unlocked. It’s a bit obscure, since you can never know how many trophies away you’re from the next level. One neat feature is that you can see what % of players have any given trophy. This is quite cool, since most people seem to not play much of the games they buy, so you end up earning trophies that few people have unlocked quite quickly. This system lacks also the feature of seeing how much progress you’ve made in a certain achievement, making it hard to know how far away you’re from unlocking it. How achievements/trophies should change: It is clear that MS and Sony have to learn from each other. Both have features the other lacks. I will use the term “Achievement” for the new version as well, since it’s the most wide-spread term. I think Playstation’s system of categorizing trophies in 4 classes makes a lot of sense, since it’s much more rewarding to unlock a gold trophy than a 50 Gamerscore achievement. It’s more tangible. It also allows for a different level of comparison, not just by comparing Gamerscores or Trophy Levels, but by comparing how many platinum or gold trophies you have vs your friends. Having more platinums give you a lot more street cred than an overall higher level. That being said, I do believe that each category needs an amount of EXP (experience points) to be assigned to it, so that you can have transparency in terms of how many more you need to earn to reach the next level. If you happen to be close to reaching a new level you might play that “one more round” in order to try and get there, whereas if you don’t really know you just leave it as something that will eventually happen. Same goes for the achievements per se. You need the system Xbox has of tracking progress of individual achievements to know if you’re close enough to invest that extra hour today or if you’ll leave it for another day. It basically tells you, for example, how many kills or levels away you are from earning an achievement. The more you play, the more games you’ll buy, the later you’ll trade them in, the more everybody wins. I remember, back in the days of the original Gears of War, how a lot of players were obsessed with reaching 10.000 (yes, that’s correct) kills on multiplayer to earn the “Seriously” achievement. It was quite difficult, since kills in matches were less abundant due to its strategic nature. The reason why it wasn’t just another achievement is because it actually rewarded you with something more than some Gamerscore points, it would unlock a profile image only obtainable by unlocking this achievement. You could set the Achievement image as your profile pic This didn’t just keep people playing the game, but it had them put on a Gears of War profile picture once achieved that everyone else would see. Free advertising. I think all achivements (gold or above) should have such an image assigned with a border indicating if it’s a gold or platinum achievement. That way you’d be able to show off, even to people who don’t own a concrete game, that you’ve unlocked platinum medal X or Y. Not just that, but I’d also give a wallpaper/theme for your console when unlocking gold or platinum medals to make it even more rewarding. Games nowadays are constantly evolving. Not just in terms of the medium but in terms of individual games. If you look at Final Fantasy XIV, The Elder Scrolls Online, Destiny or The Division, you can clearly see that these are games that have evolved drastically over time after having been released. Platforms need to give developers a way of adding achievements beyond when they release DLCs. It would require a system of approval so that they don’t just create easy achievements in order to sell more copies to achievement hunters, but it’s needed. Otherwise you end up with games with a huge asymmetry between the game the achievements were made for and the game that those achievements are currently on. There should also be timed exclusive achievements that can only be earned during a certain period of time. These shouldn’t count for getting 100% in a game, since someone might not be able to play the game during that period, but they would certainly bring some people back to games they haven’t played for a while, giving the developer a chance to show them new mechanics or content that might have been added. Nintendo had a chance of launching a kickass achievement system along with the Switch, but once more it’s missed out on a great opportunity and is launching its console without any sort of achievement system, just like all the ones before it. Even Google Play has achievements nowadays! I think there is a lot of room for improvement here and that it’s a win-win for everyone in the ecosystem to create and engaging and entertaining system. Hopefully someone will take the lead here soon and make achievements more rewarding.

Nintendo

PlayStation

Sony

Gaming needs gamification

News flash… decisions by business customers are increasingly driven by the same dynamics of peer-to-peer networks and opinions that influence consumers (e.g. Yelp, Trip Advisor…). sports a $380 billion value, in part, because of the power of the like button to influence purchases by consumers. Facebook Businesses spend $3 trillion a year on enterprise technology. Enterprise companies know that the “white papers” they publish lack independence, and thus score low in terms of buying consideration. Buyers are looking for content that combines expertise with an independent voice. That’s why “peer recommendations are influencing more than 90% of all B2B buying decisions” according to . A Gartner study found that peer networks, like are the dominant way that buyers are getting input from other end users: technology a recent HBR article IT Central Station The enterprise tech purchase path has three phases Exploration — do I want to make a change? Evaluation — what approach am I going use to make to this change? Engagement — can I work with this specific vendor? According to Gartner, during the second and third phases of the buying process, recommendations from analysts and influencers, including peer reviews, is the most important factor driving the buying decision. IT Central Station, lead by the talented , is using the power of peer reviews in enterprise tech to build a big business. For example, (Application Performance Management). Russell Rothstein here’s a review of AppDynamics APM It All Starts With The Users & Monthly Uniques Are Growing Rapidly As IT Central Station is a private company, for competitive reasons, we won’t disclose exact figures, but total visitors to IT Central Station grew 52% in 2016 vs. 2015: User growth accelerated to 60% in January 2017 over the previous January, driven by 66% growth in organic search, as Google increasingly appreciates the value of IT Central Station’s peer reviews. This enables IT Central Station content to consistently rank at or near the top of organic search results for a large range of enterprise IT products: Example of ITCS Appearing at the top of a Google Search (out of 918,000 results) Example of ITCS Appearing at the top of a Google Search (out of 431,000 results) The reason the users are coming to IT Central Station is to read in-depth reviews. While the main competitors have reviews that are 50 words long on average (Spiceworks) or 100 words on average (G2 Crowd), IT Central Station reviews are over 400 words on average, solidifying its position as the place to go to read in-depth peer reviews of enterprise tech products Syndication of Content is Adding to IT Central Station’s Reach IT Central Station has a growing list of distribution agreements with many of the leading technology publications. of IT Central Station reviews on CDW, the largest reseller in the IT industry at $17 billion in annual sales. Here is a sample IT Central Station also distributes its product reviews on leading tech media sites including CIO.com, Computerworld, and InfoWorld. Finally, in October, in another confirmation of the value of IT Central Station’s peer reviews, IT Central Station was featured in LinkedIn’s announcement that “ ”. LinkedIn Introduces B2B Product and Service Reviews Into the Feed Each of these partnerships adds significant reach to IT Central Station, enhancing it’s ability to reach the decision makers buying $3 trillion worth of enterprise technology every year. Monetization Is Growing Even Faster Than User Growth Given the dramatic impact that peer reviews have on buying decisions, it’s no surprise that IT Central Station has a blue chip roster of enterprise IT clients: Partial List of IT Central Station Clients Clients love IT Central Station reviews: AppDynamics: “Our largest deal of the year was a result of our investment in IT Central Station.”Oracle: ““IT Central Station was ranked #1 when we asked leading members of the Oracle IT community which peer-to-peer technology review sites they were most aware of.” As a result of their strong relationship with their customers, IT Central Station revenue grew 90% in 2016, driven by a 52% increase in users, and a 25% increase in the revenue per user. Revenue per customer grew 150% from January 2015 to January 2016 driven by the increase in reach, as well as the introduction of new products, most notably, the introduction of video reviews. . Here’s a video review of HPE’s 3Par Flash Storage IT Central Stations’ revenue should continue to climb in 2017 and beyond as IT Central Station continues to grow its reach, grow its customer base, and add new products. Future Opportunities For Growth Are Significant At its core, IT Central Station has built a sophisticated buyer intent database and engine built upon big data technology. IT Central Station tracks the behavior of enterprise buyers on its platform and assigns a buyer intent score, aggregating that data across other visitors from the same organization. As a result, IT Central Station knows which enterprises are currently in a buying process, which vendors they are evaluating, length of the buying process, seniority of the people involved in the process, and other valuable buyer data. Today, IT Central Station monetizes that information by enabling its clients to market to its users leveraging the intent. There is a big opportunity for IT Central Station to better leverage that information, potentially even creating its own marketplace. While that path is unchartered at the moment, what is clear is that when you have a large and growing amount of buyer intent information in a $3 trillion market, the opportunities are significant.

Oracle

IT Central Station Is Riding the Peer Recommendation Wave in Enterprise Tech

has become the go-to discovery tool for “ .” Product Hunt product-loving enthusiasts to share and geek out about the latest mobile apps, websites, hardware projects, and tech creations The platform combines peer referrals with a forum-like format and surfaces products that are both intriguing and relevant to the tech-focused community. And while Product Hunt’s site may not look like much, it has amassed a large and active following, including key tech influencers, celebrities, reporters, and more recently, venture capitalists. , the founder of Product Hunt, actively cultivated the community in 2013 and is credited with building the foundation of Product Hunt on high-quality postings only. Anyone can submit products for review, but only a small percent of Product Hunt’s monthly visitors are allowed to post in discussions. Giving special access to media companies and tech influencers first, Product Hunt has been able to play the role of gatekeeper and hold its content to a certain buzzworthy standard. Ryan Hoover Image The combination of moderation and the community option to “upvote” posts, similar to Reddit, allows visitors to decide easily whether or not a featured product or startup is worthy of exploring. With the addition of social features such as the ability to follow other users, media access to direct message product founders, and the ability to , Product Hunt may be leading the way for a tech PR revolution. Because the platform has become the ultimate spot for tech company founders to generate buzz about their products or services, reporters have flocked to “organically discover” interesting products and interact directly with the startup founders to write their stories, rather than sift through endless email pitches. curate product collections To see the true media power of Product Hunt, look no further than one of the largest Product Hunt launches ever for the simple messaging app, , in 2014. The app originally appeared on Product Hunt and spurred a large, and somewhat debatable, amount of in almost every technology publication imaginable. Yo coverage Image It’s also where started out. Within 24 hours of the startup’s launch hitting Product Hunt and social media, it created a media frenzy and the founder, Mathew Carpenter, . Ship Your Enemies Glitter sold the website for $85,000 Image Many startups have tried to recreate the success of Yo and Ship Your Enemies Glitter and have turned to Product Hunt as the launching pad to do so. And the more products that receive media attention after appearing on Product Hunt, the more likely the platform will continue to grow. Now, instead of launching in the iOS App Store or tirelessly emailing TechCrunch reporters, many startups are releasing their products exclusively on Product Hunt first. The influential community conversation and feedback have proven to be a successful way of getting a new product off the ground and receiving widespread recognition at the same time. One collaborative email client, , decided to launch the new mobile version of their app on three different channels: , and . The team then provided an analysis of the results from each channel on their blog. Front App Hacker News TechCrunch Product Hunt On Product Hunt, the app received more than 150 upvotes on launch day as well as investor interest. The team put together this SlideShare presentation, “ ” to share their results. Hacker News vs TechCrunch vs Product Hunt: which is most effective to launch your startup? Many other startups have shared their stories and advice for launching on Product Hunt as well. Here are a few worth reading: How I launched the #2 most upvoted product of all time on Product Hunt How we nailed our Product Hunt launch and made $1,000 in one day These 6 tactics got us ranking #1 on Product Hunt (and 9k+ visits) hackernoon.com Product Hunt Success stories & how tos on Hacker Noon. It’s never been easier for product creators, or startup founders, to directly communicate with industry influencers and the press thanks to social media and platforms like Product Hunt. Members of the founding Product Hunt team also launched a weekly podcast series called to cover emerging products and all things tech. The series features thought leaders in both the tech and media industries and serves as another refreshingly creative outlet for new companies to amplify their voices. Product Hunt radio The disruption of traditional media communications continues to be an important space to watch. What other platforms do you see emerging and creating new ways for startup founders to connect with the media and amplify brand awareness? Share your thoughts in the comments.

Discovery

Techcrunch

Read My Stories

Why is Product Hunt So Popular For Startup Launches?

I can’t tell you the number of times the title of this post has crossed my mind as I dug through a piece of that I hadn’t touched in years. code At the time I wrote it, I probably thought my code was beautiful. An elegant masterpiece. It should have been printed, framed, and hung on a wall of The Hall of Fame. As clever as I thought I may have been a few years ago, I rarely am able to read my old code without some serious time wasted debugging. Programming This problem plagued me . I tried different techniques to try and make my code easier to understand. regularly First I tried adding comments to my code. Pretty easy to do, but not all that helpful. When comments weren’t cutting it, I tried to write self-documenting code instead: small, well-named classes and methods that described their limited functionality. This made the code more readable but I would still have questions. I also tried documenting my code in a separate file. This had its benefits but didn’t solve the problem entirely either. Eventually I figured out what I needed to do: I needed to use all three of the above techniques to write beautiful and understandable code. truly Comments Comments in your code should document the not the . When I first started programming, I would often write very unhelpful comments like this: why, how public class Class1{public List<string> DoWork(List<string> a){List<string> numbers = new List<string>(); // Loop over data  
for (int i = 1; i < a.Count; i++)  
{  
  int s = a\[i\].IndexOf(" ");  
  string num = a\[i\].Substring(0,s);  
    
  // Save data  
  numbers.Add(num);  
}  
  
return numbers; }...} “Loop over data”? “Save data”? These comments are beneficial to understanding the code. I can easily tell that I have a loop, and that I’m adding my data to a collection, why should I waste valuable screen real estate with unhelpful comments? Instead of saying or , comments should explain . A programmer will see the loop and know that it’s looping over some type of collection of . However, a programmer will not know why we are starting our counter with — this is where adding a comment can improve the understanding of the code: what how why for Addresses int i = 1 // i = 1 because the view will never display the first addressfor (int i = 1; i < Addresses.Count; i++) {... Now, we know some of the business logic driving our app. We know we don’t process the first address because it never gets outputted to our view. This comment answers the behind skipping the first address, adding clarity to the code. why Additionally, we remove the comment completely since it adds no insightful value. // Save data Self-Documentation Comments alone won’t make code easy to reinterpret however. Let’s take at our method again with our improved comments: public class Class1{public List<string> DoWork(List<string> a){List<string> numbers = new List<string>(); // i = 1 because the view will never display the first address  
for (int i = 1; i < a.Count; i++)  
{  
  int s = a\[i\].IndexOf(" ");  
  string num = a\[i\].Substring(0,s);  
  
  numbers.Add(num);  
}  
  
return numbers; }...} What exactly is ? What kind of work is doing? What about the use of ? The names of the objects in our code don’t aid in our understanding what this code is doing. Class1 DoWork() int s This is where the idea of self-documenting code comes in: instead of creating objects with arbitrary, non-informative names (“I swear I’ll refactor this later”), we build descriptive objects. If I have a class, its name should give me a good idea about what its properties and methods could be. A method’s name should be descriptive enough to tell me what I should expect as an output without having to dig into the details of what that method is doing. Variables should add additional illumination that make and type comments obsolete. what how In our example, let’s make our code self-documenting. First, this class is intended to help us clean address data. Let’s call it . With that simple renaming we know that all of the properties and methods of this class should pertain to dealing with dirty address data and making it cleaner. AddressStandardizer What about the method name ? Well , I can tell you that this method is trying to parse out the number portion of a street address. So let’s change the method name and signature to something more informative, like . Now we can make an educated guess that this method accepts some address strings as an input and and it will return a list of parsed house numbers. List<string> DoWork(List<string> a) List<string> ParseHouseNumbers(List<String> addresses) If we clean up some variable names, our code becomes much easier to read, like this: public class AddressStandardizer{public List<string> DoWork(List<string> addresses){List<string> houseNumbers = new List<string>(); // i = 1 because the view will never display the first address  
for (int i = 1; i < addresses.Count; i++)  
{  
  int firstSpaceIndex = addresses\[i\].IndexOf(" ");  
  string houseNumber = addresses\[i\].Substring(0,firstSpaceIndex);  
  
  houseNumbers.Add(houseNumber);  
}  
  
return houseNumbers; }...} Documentation Our code is finally starting to shape up. We have comments explaining we chose to do something and we refactored our code to have object names that are informative. why The code at this point is ok but not perfect. If we don’t look at this code for a few years, we probably have enough information now to look at the code and figure out what it’s doing with relative ease. The big piece of information that we are still missing however is knowing why this code was written in the first place. Often times, I get a question from a manager or analyst about why we decided to build the project in the first place. Or I’ll get a request for information about how the logic in the program works. Without a proper documentation file, the best thing I can do is send the business user a copy of my code. Most of the time that isn’t very helpful. What would be helpful though is an explanation of what our program is doing at a high-level. This is the purpose of formal documentation. The documentation for this section of code might look something like this: …After retrieving our customer information from our vendor, the program processes the data and cleans it up to load into our reporting warehouse. Cleaning up the data means parsing the addresses into multiple columns including house number, street name, street suffix, city, state, and postal code… Now, when a business user needs to know what your program is doing, you can easily send them the above documentation their way. The documentation also acts as a nice refresher for you, the programmer, when it comes time to revisit the code, as well as any future coworkers who will be new to the project. Wrap up All of these techniques are necessary to eliminate code headaches down the road. Learn from my experience — not doing all three may save a little bit of time in the short term but it will hurt at some point in the future. Once you get in the habit of writing all three kinds of documentation, it will become second nature and make your life (and the lives of your future-self!) much easier. Comments in code should explain the why not the how: The should be explained by well named classes and methods how Separate documentation still needed for developers and non-developers alike. Think of business users who need to know how your process works and the business logic that is in it; nice to have high-level document explaining the business uses of your process that someone non-technical can understand.

Different

Mind

“What the #@$% was I thinking!?” How to write understandable code

Mobile app users are fickle people. It is very common for people to download an app, use it once, and never return. In general, will stop using an app within the first 3 months. People leave apps for different reasons: poor execution, annoying ads, a misleading app description, or boredom. The list of reasons could go on and on. But a big reason that users churn is because the app failed to create a relationship with its users. Without a relationship, the user does not feel compelled to return to the app. They have no brand loyalty. 75% of users Think about where you buy your food. In the US, most people have easy access to several different grocery stores but often shop at the same store over and over. When you go in that store, you trust that they will have the products you are looking for. You trust that the prices will be reasonable. You trust that the employees will accurately ring up your bill. The recurring word here is trust. Because you trust the store, you are loyal to them. The key to retaining users is to gain their trust. They need to trust that you listen to their concerns. They need to trust that you will make the best product possible. They need to trust that the app will function in a way that provides them value. So how do you build trust with your users? Listen, Communicate and Encourage. Listen Apps are not one-way streets. As an app owner, the product you made is your vision, but it might not fit with your user’s vision of the product. So how do you find what your user’s vision is? Ask them. Add an easy way for users to submit their feedback to you, like an email form or an in-app feedback system. Relying on app store reviews as your feedback channel is a bad idea. Even though app stores allow you to reply to user reviews, that is not a great way to have a continual conversation with your users. Plus, having negative feedback on the app store is an easy way to decrease trust for potential new users. A good listener is one who is slow to speak. Let your users speak their minds. Yes, often user feedback can be harsh and it is hard to hear someone rip apart all your hard work. But constructive criticism is a great way to learn your user’s pain points. If multiple people mention the same thing, then that is an area you need to address. You can also indirectly listen to your users through analytics. In retail stores, customers vote with their wallets. In apps, customers vote with their clicks. By looking at your app analytics, you can see how users are using your app. Are they clicking through your app and getting stuck? Are they confused on where certain content lives within your app? Is your navigation not intuitive? These are all ways to listen to your users without them having to say a word. Communicate Nobody likes one-sided conversations. That’s like talking to a wall. Don’t let your app be a wall. When a user sends you feedback, respond to them. Even if you can’t answer their question right then or they ask for a feature that won’t be developed for months, let your user know that you heard what they said. Many help desk programs automatically send a response email when you submit a new trouble ticket. That email usually says something like “We received your message and will respond within 24 hours.” Personally, I don’t like these. They do serve a purpose to show that your message was submitted, but as a customer, I want my message to be received by a human, not a robot. How many times have you called up a telephone support line and had to wade through 5 minutes of “press 1 for X or press 2 for Y”. I normally just start pressing 0 because I want to talk to a human operator, not a robot menu. I want to hear the empathy from a fellow human about my problem. When a user submits feedback to your app, have a human write them back. Let the customer know that you care about their problem and want to make it better. Even if their question is very basic and the answer is extremely clear to you, it obviously has caused them some frustration. User feedback isn’t the only way to communicate with your users. In-app messages are a great way to highlight recent changes to your app, or to wish your user a happy holiday, or just to add a more human feel to your app. The goal is to build a relationship. In the real world, sometimes your friend calls you first; sometimes you call your friend first. Either way, you are having a conversation with each other and increasing the strength of your relationship. Just don’t be that annoying friend that calls ten times a day. You need to use your judgment and determine how often you should message your customers so that it increases their trust without making them annoyed at you. And most of all, in all your communications, be honest. Honesty is one of the quickest ways to gain user trust. If your app messed up and erased all your users data or the user was overcharged for an item, do your best to correct the situation and then own up to the problem. Encourage No app is used 24 hours a day. So there will be times when your app is not in use. Nudging your users back into your app with push notifications is a great way to increase retention. But just like in-app messages, nudging too often or with the wrong message will just make your users angry. Think about when you should send push notifications. If your app has users all over the world, sending a blast push notification at 10am US Eastern time means that users in Japan will get the message at midnight. If the message doesn’t make your Japanese users angry because you woke them up, they may just ignore the message all together when they check their phones first thing in the morning. An easy way to address this problem is to send the message at the last time they used your app. So if a user opens up your app at 5pm local time, make sure they get the push notification at 5pm local time. This will increase the chances that they interact with that notification. Many users have short memories and often don’t remember what they did yesterday. They may have already forgotten that they downloaded your app yesterday. In this case, you can send out a friendly reminder 24 hours after they downloaded your app. The message doesn’t have to be anything complicated, just a little something to jog their memory about your app. Maybe your app rewards users for reaching a certain level or achievement. A few hours after achieving that goal, send them a short congratulatory message. It can be a short message to show that you are happy for them and encouraging them to reach the next level. This goes back to the human touch aspect. Even if an automated process sends your messages, make them feel like a real live human, not a chatbot, has sent them. All businesses strive to create loyal customers. Trust doesn’t happen overnight, but instead happens through lots of small interactions. Everything you do in your app should be about making your customer feel like you have their best interest in mind. As independent app developers ourselves, we created to help us reach our customers and gain their trust. If you want to increase your user retention, give it a try. User Hook If you are looking for help with a digital project, check out our company . We also help mobile apps with user engagement and feedback through our service. Cullaboration Media User Hook

Keep

3 Ways To Gain User Trust in Mobile Apps

Part I. Problem and first solutions. project launched in 2004 now became an industry standard for browser automation. However if your QA department is relatively big, sooner or later you will face to recommended limitations. In this article I would like to tell you how to create a scalable and fault-tolerant Selenium solution easily. Selenium Selenium architecture Problem Selenium architecture radically changed several times since 2004 when its first prototype was created. Current Selenium architecture introduced in 2.0 branch is called Selenium Grid. It works like the following: Usually a cluster consists of two daemon applications: Selenium Hub and Selenium Node. A is an API that handles user requests and redirects them to respective nodes. A is an actual request executor launching browser processes and requesting desired test steps from them. In theory an unlimited number of Selenium Nodes can be connected to one Selenium Hub and every node can launch any installed browser. But what’s in practice? hub node Such architecture has a weak part. Selenium Hub is a single browser access point. If it goes down or does not respond all browsers become unavailable. The same happens if a datacenter with hub is powered off or its network fails. Selenium Grid does not scale well. Our 5+ years of Selenium cluster expertise show that even under moderate load a hub can work with a limited number of connected nodes. Depending on hardware even dozens of connected nodes can dramatically increase hub response time. No quoting functionality. You can’t create users and specify browser consumption limits. Solutions The simplest scalable approach is to use multiple Selenium Hubs distrubuted across multiple datacenters. However standard Selenium libraries can only work with one Selenium hub. We need to teach them to work with such distributed system. Client-side load balancing An initial approach we successfully used several years ago was a client library that did client-side load balancing. This is how it works: We launch multiple Selenium Hubs and respective Nodes in multiple datacenters. A list of hub hostnames with supported browsers is saved to file. Selenium user attaches a small client library as a dependency to his tests and requests a Selenum session using the library. The library reads the file with hubs and randomly selects one of them having desired browser. Then it requests a browser using standard Selenium client. If session is created successfully then test steps start executing. Otherwise the library tries another hub host until a session is created. Different hubs can contain different quantities of browsers. To deliver uniform load distribution we need to assign different weights to hub hosts and then select these hosts according to their weights. If the client fails to create a session on every hub from the list — it should throw an error. A single line of test code (new session request) should be changed to support that library. For example in Java tests a new session request may look like that: WebDriver driver =new RemoteWebDriver("http://my-hub.example.com:4444/wd/hub", caps); All classes in this code come from a standard Selenium Java client. E.g. if a client-side library is called SeleniumHubFinder a new session request will look like: WebDriver driver = SeleniumHubFinder.find(caps); No Selenium hub URL is used in updated code — this information is stored inside client library. That’s it! This approach worked for years. Hundreds of software testers in our company were satisfied. What are the drawbacks of using client library? A supplementary library should be added to every test project. You can’t launch your test without this library. A separate client library should be implemented for each language. E.g. Javascript, Java or Python Selenium tests may exist in your company. In that case you need to support several client libraries and ensure that hub lists are in sync. That’s why a server-side solution is necessary. Server-side load-balancing Relying on our experience with client-side solution we introduced the following natural requirements to server-side one: The server should look as Selenium hub to client libraries. To achieve this it should implement . Selenium JsonWire protocol Any number of server nodes can be installed in any datacenter. They can be installed behind any software or hardware load balancer. Server instances are stateless. They don’t use neither database server nor queue server to share state. Server should support multiple users and quoting. We called the server — GridRouter because the only thing it does is routing user requests to correct Selenium Grid Hub. Here’s the new architecture: The load balancer distributes user requests across multiple GridRouter instances. Every GridRouter instance stores information about all available Selenium Hubs like client-side library did. To handle new session request GridRouter uses the same random distribution algorithm. As you probably know every new browser session in Selenium automatically obtains an ID called session ID. According to Selenium JSONWire protocol this ID is always passed to request. GridRouter appends information about selected Selenium Hub to this session and returns enriched session ID to user. After session is obtained GridRouter extracts used Selenium Hub information from enriched session ID on each following request and simply proxies it to a corresponding hub. Since all session information is stored in its ID there’s no need to synchronize GridRouter instances. This is why GridRouter is stateless. GridRouter Initially we implemented GridRouter using Java, and . Its source code is available on . This implementation is using a plain text properties file to store users list and an XML file to save a list of Selenium hubs for each user. A typical users list (by default ) looks like the following: Jetty Spring Framework Github /etc/grid-router/users.properties user:password, useruser2:password2, user Every line corresponds to one user. Passwords in current implementation are stored without any encryption. This is because we consider that users are mainly needed to account browsers consumption by different teams. Selenium hub lists are stored in XML files of the following format (by default ): /etc/grid-router/quota/*.xml <qa:browsers xmlns:qa="urn:config.gridrouter.qatools.ru"><browser name="firefox" defaultVersion="33.0"><version number="33.0"><region name="us-west"><host name="ff33-hub-1.example.com" port="4444" count="5"/></region><region name="us-east"><host name="ff33-hub-2.example.com" port="4444" count="5"/></region></version><version number="37.0"><region name="us-west"><host name="ff37-hub-1.example.com" port="4444" count="3"/><host name="ff37-hub-2.example.com" port="4444" count="4"/></region><region name="us-east"><host name="ff37-hub-3.example.com" port="4444" count="2"/></region></version></browser><browser name="chrome" defaultVersion="42.0"><version number="42.0"><region name="us-west"><host name="ch42-hub-1.example.com" port="4444" count="10"/></region><region name="us-east"><host name="ch42-hub-2.example.com" port="4444" count="10"/></region></version></browser></qa:browsers> You can see that we define available browser names, their versions and a set of hosts distributed across multiple regions. A region in our terms is just a datacenter. Information about datacenters is mainly needed if one datacenter goes down. We select a host from another datacenter if the first session attempt fails. This approach increases the probability of faster Selenium session creation. Using GridRouter in tests As I previously said GridRouter implements standard Selenium protocol and is fully compatible with all existing client libraries. The topic we have left is how to authenticate in GridRouter i.e. specify which quota we want to use. All Selenium client libraries support only one authentication method — . That’s why GridRouter supports only this method too. Usually Selenium hub url is like the following: Basic HTTP Authentication http://example.com:4444/wd/hub As you probably know basic HTTP authentication username and password can be encoded to URL like that: http://username:password@example.com:4444/wd/hub This is the only change you need to do in your code to use GridRouter instead of Selenium Hub. The majority of Selenium client libraries including Java and Python implementations work with such notation. Some Selenium-based Javascript tools however require you to specify username and password as separate configuration options. Selenograph GridRouter allowed us to stop using client-side libraries. It gave users with different languages access to a scalable Selenium installation. To scale GridRouter installation you just need to add more Selenium hubs to its XML configuration — all changes are applied automatically without service restart. To serve more requests per second you also need to add GridRouter hosts behind load balancer. Our experience shows that GridRouter works perfectly when total percentage of used browsers of any version is below ~80%. Problems begin when the peak load arrives and browser consumption grows up to 90–100% of total capacity. In this case the random uniform session attempts distrubution becomes inefficient. We are trying to obtain Selenium session on fully occupied hub too often and do attempts to several hubs before returning session to user. This increases session start time and slows down tests. Our next stage in Selenium cluster development aimed to resolve the issues above was a new product called . Selenograph is a Java server based on GridRouter source code fully compatible with its configuration files. The main differences are: Selenograph It is stateful. To be more efficient on high loads Selenograph is using more sophisticated algorithm of choosing hub hosts. The main idea is to dynamically adjust hub host weight by considering total number of already running sessions. This number should be saved to storage shared among Selenograph nodes. We use as such storage. MongoDB It provides more statistics and user-friendly interface. For example Selenograph API can return total number of concurrently running sessions at each moment of time. Although Selenograph is a stateful solution it is confirmed to work correctly under high load allowing to serve hundreds of requests per second to every instance. Conclusion In this part I told you about standard Selenium scalability problems and how they can be resolved with minor changes to your cluster architecture. In the next part we’ll discuss topics like: How to prepare worker nodes for big cluster so it scales well Some thoughts about nearest Selenium future How to run Selenium inside Docker containers What are the new open source tools that will help you to deploy an efficient Selenium cluster with low resource consumption Stay tuned…

Selenium testing: a new hope

Every Intelligence researcher has probably a vision of how intelligent machines will reshape the world. My idealistic view is one in which automation maximizes people’s freedom by giving us more time to concentrate on the things we enjoy the most. Research in all areas is astonishing: we live better and longer, and our planet has started to heal. Robots lead to superlative boosts in productivity, and an unprecedented abundance reduces tensions amongst people. We have more time to learn and inform us, and machines enable us to manage much more knowledge, so we take better decisions. Artificial This romantic picture may be regarded as overly naive as, some would say, it disregards the immediate social implications of AI achievements. As AI becomes more pervasive, a debate around a scenario in which machines scrap people jobs- high and low skilled- is gaining steam. The discussion centers on the social disruptions generated by robots taking a prevalent role in the production system. So far, economists have assumed that human effort will always be required. Technological change just shifts low productivity workers (more likely to be replaced by ) into more productive tasks, increasing everyone’s well-being. Technology augments human capabilities and creates more skilled jobs. Even though specific positions disappear, people can continue working alongside machines in new roles. In this perspective, the debate around technology focuses on the education and training of the labor force. technology However, critics (from left and right) are questioning whether this assumption still holds true. They believe to be supported by raw statistics. , as for today, around 45% of human jobs could be automated in the service sector. , 50% of the work time is spent on processing and collecting data, activities that AI systems can do quite well. , the perspective is even more dramatic: Automation accounts for almost 90% of the job losses in the US between 2000 and 2010. Experts agree that as AI gets more sophisticated more skilled jobs across all sectors will be eliminated. The consultancy McKinsey estimates that In the financial sector only In manufacturing Fear of machines is certainly not new. At the wake of the first industrial revolution destroyed machines to preserve jobs. Nowadays, those worried about robots making humans dispensable are proposing (fortunately) more sophisticated approaches. Even high executives of billion-dollar tech giants- unlikely guests of the -, are talking about socialist-friendly policies such as a universal basic income to limit the effects of automation. Luddites Fourth International The idea behind this thinking is that if we reach such a developed state of AI with little or no need for human labor, then society will divide itself between few machine owners and the rest. Most of the people without owning a robot will lack any income to buy what robots produce. At least at the surface level, this idea appears to have some commonalities with Marx’s view of the evolution of capitalism. Marx idea of socialism as the next stage of capitalism could be (with apologies to experts) oversimplified in the following way: Capitalism leads to a natural concentration of wealth (mostly via technological change), where few capitalist get increasingly more, and a majority of workers increasingly less. The later will eventually rebel and establish a socialist system. However, things did not happen exactly like that. Even though income inequality might be increasing, technological change led to sharp boosts in productivity, allowing everyone to be better. Marx’s workers might be relatively worst (they take a smaller share), but they also enjoy higher life standards with more goods and services available. No worth the effort of rebelling. But what would happen if instead of making a worker produce more, machines completely replace that worker? Depriving him of any income could make the option of rebelling more appealing. Ironically, this situation might also be the end of Marxism since human labor will not be generating value anymore (apologies with experts, again!). If machines do all the work, there is no theory exploitation, and Marxism might cease to exist (it seems that even Marxist theoreticians may lose their jobs). Marxist or not, the prospect of unhappy masses with no means of subsistence might be enough to generate a general outcry to establish some sort of direct wealth redistribution. The proposal of a basic universal income is gaining support among businesspeople and politicians. Benoît Hamon, the French presidential candidate of the, currently in power, socialist party . If he succeeds, every French citizen will perceive 750 euros every month no matter what, which will be, in principle, funded by robot owners. has proposed to finance the initiative by taxing robots Also from the not so socialist side, top executives from multi-billion dollar tech companies are considering the idea. They agree that the impact of automation is beyond anticipated and its consequences are getting difficult to measure. that “there is not one more important [topic] for all of us” than technology creating inequality and concentrating massive wealth in just a few people. She even called for an ethical rule book for AI. In Silicon Valley, the idea of “universal basic income” does not seem to be marginal. Vishal Sikka CEO from Infosys said that “a fraction of the cash that the top 10 or top 50 tech companies have could solve a big part of the basic income problem”. Ginni Rometty, CEO of IBM, said in Davos A fear response or not, neo-Luddism or not, there seems to be, at the moment, a consensus that the path lead by AI won’t be that smooth and that some collective action is required. Either by direct wealth distribution, or more traditionally, via a broader and inclusive education system. Fortunately, there seems to be also a consensus that AI is a good thing and no one proposed so far to break machines (or AI researchers as in Terminator) but to alleviate the undesired consequences that technological advancements might cause. Varied views on the topic: — The Economist Rise of the machines — The Economist Automation and anxiety — Bloomberg Artificial intelligence: Disruption era begins — Bloomberg A Robot Tax Is a Bad Idea —FT How robots are making humans indispensable — Socialist World Will robots end capitalism? — Conservative Home How the rise of the robots could give socialism a second chance? is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Alongside

Is AI driving humanity towards socialism?

Since the marches that followed the Inauguration, the morose disbelief among those who didn’t vote for Trump has been almost entirely replaced by an energized, passionate commitment to action. This is awesome! The marches weren’t just fleeting demonstrations, they were : . awakenings there are many of us, and collectively we can make an impact One thing I’ve seen a lot, particularly among friends in tech, are posts wondering how best to help. Should we donate money? Should we donate time? What else is there besides petition-signing? It’s easy to get overwhelmed when everyone is posting about an action, petition, march, or hackathon. (Squirrel!) So, I’m writing this because I felt that way, but still managed to get myself pretty involved in some policy issue activism two years ago. In particular, I was able to put the skills that I use in my career to work on issues that mattered to me, and that was incredibly rewarding — making calls and knocking doors is great, but there is more out there. You have skills that really matter. If you can code, that’s valuable. If you’ve worked at a startup and made sales or marketing magic happen with zero budget, you are needed. Been part of the fundraising apparatus (VCs, looking at you)? Your skills and network are in demand. There are some groups coming together that are specific to tech workers, and I’m going to give a shoutout to 3 efforts that I think have a lot of potential. (I plan to keep updating this list, so shoot me a note or leave a comment if you know of good groups to point people to) is a new project to help connect talented tech industry folks with longer-term volunteer opportunities in campaigns. Think of it like "Teach for America" but for helping out campaigns that need your skills (including analytics, performance marketing, customer success, inside sales). This is a great way for non-engineering startup people to put their skills to work. Tech Talent for Campaigns political is an initiative that is encouraging workers at larger tech companies to take action from the inside to effect change. I think this is an incredibly powerful idea; while I’m not sure to what extent the drove the change, Facebook is now taking the fake news problem more seriously. Employees really can be effective at raising concerns from the inside. Follow the Twitter account to be kept up to date on events in your city. Tech Solidarity Facebook mutiny is by and for data scientists and enthusiasts. “ are focused on , election transparency, a USA dashboard (like KPIs for America), analysis on the extreme right, , and (in support of work by ). These projects are all self-organized and community led.” Data for Democracy Our active projects understanding the behavior of online communities Medicare drug spending campaign spending ProPublica Pick 1–3 specific issues that you want to focus on. There is a lot that’s wrong in the world right now, and a ton of different planks in the current administration’s platform that really suck. But there are 24 hours in a day and we have jobs and family responsibilities. You can’t personally fix everything, and you’ll burn out if you try. So to have the greatest impact and limit burnout, identify what’s most likely to keep you passionate and engaged and go after that. I personally am planning to participate in a) efforts to reduce the spread of disinformation and propaganda on social networks, and b) assisting legislators who are working to pass evidence-based science and health-related policies at both a state and federal level. Other folks I know are targeting specific policy areas — immigration, housing, gun violence, preserving access to healthcare. Still others are focusing on specific people — getting particular individuals or particular types of candidates into office locally, or in the midterm elections. Network, network, network If you want to focus on a particular cause or policy issue, search Groups. It’s a very popular tool for coordinating collective action, and god knows we need more non-troll/non-extremist collective action groups to offset what currently exists out there. Facebook You can also plug into your preferred political party’s local club, be that Democrat, Libertarian, Green, #NeverTrump conservative, etc — they’re all on Facebook. Get on to learn about or help with issues at a local level. You can even call your representative or look at state or federal bill trackers (or sites like ) to see if there’s legislation pending about topics you care about. Then contact the bill sponsor’s office to see if there’s anything you can do (here’s about that). Nextdoor POPVOX my story Put yourself out there, if you’re able to. If you find a group or cause that you’re passionate about, tell your friends about it. You’d be surprised at how many people will come out of the woodwork because they’re also looking to make a difference, even if your Facebook feed feels largely apolitical. Take the biggest leap: run for office yourself There are tons of groups popping up to help make running for office a reality for a more diverse set of people — some are looking to help minority candidates, others to help younger generations step up. If you are interested in this idea, even in passing, look over these resources. Most host regular webinars or have info packets to help aspiring candidates develop a sense of the process. A few do in-person trainings and camps. The Wellstone Foundation The Arena NextDems Runforsomething.net (under-35) VoteRunLead.org (women) (note: VoteRunLead.Org is hosting their next one-hour online class for women, “From Protestor to Politician,” on January 31st.) Emerge America (women) (note: Emerge America is hosting a two-hour online training for women, “Getting Ready to Run,” on Thursday, February 2nd.) She Should Run (women) Emily’s List (pro-choice women) VoteVets (veterans) 314 Action (scientists, STEM professionals) It would be great to see some really qualified candidates come out of the tech community; it currently isn’t a common path and we need it to be. At a minimum, most of us would do a better job at understanding The Cyber. into politics Let’s get out there. Hopefully some of this was useful. If you’ve found a helpful group for either tech-skills organizing or running for office that I should add to this list, please send it my way! is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Twitter

“What can I do?” How Tech can #Resist

I’m a Time Warner Cable (TWC) cable internet subscriber. I pay ~$100 a month for whatever their fastest internet speed option is in my area. My Eero wifi router will regularly report speeds as high as 130 Mbps down and 30 Mbps up, which would be great. However, I have had constant buffering issues with any video streamed over my home network. Netflix shows, movies streamed from iTunes, and the most frustrating of all, videos on Instagram all experience terrible load times, buffering, dropped connections, etc. I’ve noticed that essentially any data obtained from a content distribution network (CDN) will experience these issues, while traffic from other sources has no problems. As evidence of this, I can show ~30Mbps down from Speakeasy’s Speedtest: …while 10 seconds later, Netflix’s Fast.com shows 7.8 kbps: Tier 3 TWC tech support insists the problem is my local network. I’ve gone through three modems, and 3 high end routers (currently on an Eero), and all setups show the exact same issue. Can anyone propose why my local network would treat CDN traffic differently than other internet traffic? Is this even possible? If I’m correct in saying this problem is on TWC’s network, this is essentially a violation of Net Neutrality, even if it’s inadvertent. I don’t think it’s fair to advertise 80 Mbps down if the most common source of internet traffic (Netflix) is experiencing 7.8 kbps down.

Instagram

Netflix

Time Warner Cable is Not Neutral Toward CDN Traffic

Recently, I read a post on Hackernoon by Aashay Sanghvi titled “The Startup Scene at Harvard”. It was very well-crafted and I found it super interesting to take a peek into the startup scene of a top entrepreneurship school in the nation. It inspired me to write my own version of the post to give prospective Brunonians an idea of what Brown is like and to give past alums some pride on how much the scene has grown since they graduated. If you haven’t read his post yet, check it out below! _Dropping out is normally what comes to mind when people think of “Harvard” and “startups.”_hackernoon.com The Startup Scene at Harvard When you think of hubs for undergraduate entrepreneurs, is usually not the first university that comes to mind. Harvard, MIT, or Stanford usually take that laurel but Brown University is certainly on the rise. With the creation of a new centralized physical location for entrepreneurship, Brown’s scene is booming. Here’s the scoop on some of the things happening on Brown Street nowadays (as of Feb. 2017). Brown startup Clubs: EP is a student-run entrepreneurial initiative on campus and the biggest hub for young entrepreneurs. It is the umbrella organization for many great entrepreneurial resources on campus including Innovation Dojo, Startup Office Hours, Startup @Brown, and many others! Its alumni board consists of notable alumni such as Jeff Stibel, co-founder of Bryant Stibel, and Bob Goodman, a board member at Bessemer Venture Partners. This semester, its budget nearly doubled due to generous alumni funding so expect bigger and better things from them! Brown Entrepreneurial Program (EP) : Innovation Dojo is an EP workshop series that aims to introduce 1st and 2nd year Brunonians to entrepreneurship and the resources available to them on the hill. They hold meetings every week where experts give masterclass workshops on a variety of topics in entrepreneurship. All of this ties into a personal project where you work on your own startup or plan one out for the future and present it to the entrepreneurship community! Innovation Dojo : The Rhode Island School of Design (RISD) is the sister school of Brown and all clubs at both schools are open to students from both campuses. RISD E’Ship has a strong network of student entrepreneurs as well as its own startup accelerator program, E Partners Program, that provides funding and mentorship to student ventures. RISD E’Ship : HCRI is a student group dedicated to the advancement of robotics as a means to benefit human society economically and socially. Their aim is to create and understand robots that coexist harmoniously with humans. They often put up visual and interactive presentations on the bottom floor of the Computer Science building (CIT) to showcase their recent works. Humanity-Centered Robotics Initiative : A collaboration between the Warren Alpert Medical School of Brown University and the Rhode Island School of Design, Design+Health is an incubator which encourages students across all disciplines to develop and implement design solutions that address clinical and public health concerns. Design+Health : VC Presence: DRF is a student-focused venture fund of First Round Capital. They’re the largest student-run venture firm in the nation, funding and supporting an incredibly talented community of student entrepreneurs which now includes the Brown community, as they recently brought on Haris Memon (Brown ’19) as Head of Marketing for the firm. Dorm Room Fund : To date, Dorm Room Fund has made 125+ investments. Their portfolio companies have gone on to raise $200M+ in follow-on funding from investors like Andreessen Horowitz, Sequoia Capital, and Y Combinator. RDV, like Dorm Room Fund, is a student-focused VC firm backed by General Catalyst. It currently has a strong presence at universities in Boston and NYC, and our very own Valentin Perez (Brown ’18 + Former Co-President of Brown EP) is a partner. Rough Draft Ventures : Rough Draft Ventures has made 90+ investments, with portfolio companies raising follow-on funding of $230M+ from investors like SV Angel, Y Combinator, and Lerer Ventures. : Evertrue Ventures is a community of Brown alumni, investors, entrepreneurs, and innovators with a passion for supporting Brown alumni-led startups. Evertrue Ventures Events: Startup@Brown is a two-day conference hosted by EP every fall for startups across the nation come together on Brown’s campus. Many come to find new talent to join their team as well as hold office hours for young entrepreneurs looking for advice or someone to bounce ideas off of. Workshops led by industry professionals are held throughout the day where students can learn about accelerating their startup, plotting a career in tech, or building a healthy startup culture. This year, Startup@Brown was held in October with speakers coming from notable companies including Rough Draft Ventures, WayUp, and Techstars. Startup@Brown: We@Brown, the Women’s Empowerment Conference, aims to empower women to pursue their professional passions. Hosted by the Lady Launchers team at Brown EP, this year’s event will feature prominent female leaders in business and tech including Melanie Whelan, the CEO of Soulcycle, Laura Thompson, a VC Investor at Google Ventures and Co-founder of Runa tea, and Marian Salzman, the CEO of Havas PR North America. WE@Brown : In an all-expenses-paid trip, students will have the opportunity to visit a startup hub with their peers at EP. Activities include private tours of notable companies, dinners with successful Brown alumni, and opportunities to network with professionals in entrepreneurship and technology. In the past, Synapse has paid visits to NYC, SF, and LA, visiting companies such as KPCB, Apple, and Dropbox. In the future, Brunonians may have the opportunity to experience business cultures in a variety of different countries. Synapse: Hack@Brown is a two-day hackathon hosted by Brown, bringing hackers of all skill levels from all around the country together to spend a weekend programming, networking, and learning new technologies. Workshops are held before and throughout the event. Hack@Brown is a staple event for any CS concentrator at Brown. Hack@Brown: Nelson Center for Entrepreneurship A recent addition to the Brown startup landscape after a $25M donation from Jonathan Nelson ’77, the Nelson Center for Entrepreneurship acts as a nexus for entrepreneurial education by giving the community a visible space for all of its resources. Startup Office Hours, which brings highly-accomplished individuals from around the community to Brown to have one-on-one meetings with aspiring students entrepreneurs, calls the Nelson Center its home. The center also has five Peer Entrepreneurs-in-Residence (PIERS) who provide guidance and mentorship to those working on a new venture or are interested in learning how to join the entrepreneurial community at Brown. Along with these personal mentorship sessions, the center has held startup event series, , and film screenings for the community. The center is currently operating out of a temporary location right now but once the official center is completed next semester, its activities will only ramp up. major academic conferences Cool Startups at Brown: DocTalk mobile app that seeks to tackle many of the inefficiencies of the healthcare system in India. It facilitates interaction with your doctor by creating a clear channel of communication with them through the app, hosting on-the-go storage for all your medical files, and providing a means for effortless mobile requests for your prescriptions. Founded by Krishna Chaitanya Aluru ’17 of Brown, Akshat Goenka ’14 of Wharton, and Vamsee Chamakura ’17 of IIIT, DocTalk is currently going through Y-Combinator’s winter batch. DocTalk : is a Nomnomz offers two services: Nomnomz Checkout, which provides self-service checkout kiosks for restaurants, and Nomnomz Collegiate, a food pre-ordering service tailored for college campuses. It’s founder and CEO, ’18, is a strong contributor to Brown’s startup scene. Nomnomz : Matthew DiMarcantonio Bonsai is a high-end fashion and lifestyle marketplace HQ’d in Toronto. The team has raised over $780,000 in its first two funding rounds and is partnered with notable brands such as Acne Studios, Helmut Lang, and Balmain. Its Co-Founder & CFO, Kunal Khemani ’19, is currently taking a semester off in Toronto to devote full-time attention towards the platform. Bonsai : Speechify is a text-to-speech software that allows the user to listen to any text with a voice and speed of their choosing. It boasts multilingual support across accents and languages and makes efficient use of keyboard shortcuts for a smooth experience. Another nice feature of the app is the ability to create custom audiobooks instantly by highlighting any text on your phone or computer. Its founder Cliff Weitzman ’18 was recently recognized as a part of the 2017 Forbes 30 under 30 list in Education. Speechify: Bruno Innovation for Life: Our strong entrepreneurial spirit on campus has led to some amazing startups being founded by alumni, including: Casper ( ‘12, ’12, Gabriel Flateman ‘12) Neil Parikh T. Luke Sherwin Warby Parker (Andy Hunt ‘04) TeeSpring ( ‘11, ‘11) Walker Williams Evan Stites-Clayton Slideshare. ( ’98, Jonathan Boutelle ‘97) Rashmi Sinha Despite some of our alums raising over $100M for their startups and growing their teams in offices around the world, they still contribute heavily to the Brown community by offering advice and mentorship to current students and participating in conferences and workshops. If you’re interested in learning more about entrepreneurship@Brown, check out this recently released web hub, courtesy of Wesley Dencker ‘19 and the rest of the Tech team over at EP: _Entrepreneurship and Innovation at Brown and RISD_innovateonthehill.com Innovate on the Hill

Andreessen Horowitz

Apple

Dropbox

Funding

Instantly

Laura

Super

TechStars

Y Combinator

he Startup Scene at Brown

To “run the gauntlet” is to be forced to run between two rows of soldiers armed with pikes who are allowed to strike out and attack you. As a developer, you run the gauntlet every day. At the risk of a little hyperbole, every time you write a call to access a feature of an operating system, external application or service, a new pike-wielding soldier appears on your gauntlet. If that call is to a system whose stability and unwavering interface is proven, its soldier on your gauntlet is essentially disarmed. But when that call is to a new system, or an application with a periodically adjusted, ill-defined or poorly understood interface, their soldiers become armed and your gauntlet becomes perilous. Such are the deadly costs of run-time abstractions. Once upon a time, when we told the hardware directly what to do there was no operating system to call upon to grant access to higher level features. In this simpler time, our gauntlet was completely devoid of soldiers (and certainly devoid of pikes!). We had a clear path. Then, out of necessity, we introduced the first run-time abstraction; the operating system, an independent ‘application’ that acts as gatekeeper of hardware and software resources. At this point, instead of directly instructing the hardware, we asked the OS gatekeeper to do things on our behalf. It was at this point that our gauntlet became… a gauntlet. Over time, as the gatekeepers and their interfaces became more reliable, its soldiers were disarmed. They’re relatively harmless now. Today, developers who express their program requirements in languages with no run-time environment such as C can mosey on down a completely disarmed gauntlet. That is, until the time comes that they need to expose their code to higher level languages. Take one quote from a developer: “Almost any systems code I write these days is something I’ll eventually want to expose to a high-level language. […] Having lots of rich concepts and semantics in your systems language just gets in the way, because you have to find out how to map between the two.” But this mapping (through language binding, FFI’s or ABI’s etc.) often then introduces run-time dependencies in to the OS, which only means one thing; . (Not to mention the unnecessary ‘glue code’ required to map between the two languages, code that doesn’t contribute any functionality toward meeting the application requirements!) addition more soldiers and more pikes And then what about the more ‘complex’ languages, ones with extensive run-times? And whether or not they’re armed depends on how well the language is maintained, and how stable its runtime environment is. Garbage collection, for instance, certainly comes with its own set of soldiers (usually armed). Still more soldiers. What about frameworks? Same thing. “Don’t pike us, we’ll pike you!” And micro-service architectures? Same thing, but now you’re at risk of being piked by “friendlies”! Take the following Reddit exchange that took place mere days ago in a thread titled : “Everything should be [a] microservice” Dev 1: “We just had a discussion in the team, and we decided, that we need “add-one” microservice that would get a number and return the number increased by one. A nice separation of concerns in modern distributed web application :)” Dev 2: “That’s an awesome idea. Finally someone spent some time thinking about the overhead of computing this locally compared to simply creating an http request, waiting for the answer, processing the answer and parsing the value. This as a microservice will be so much more efficient than adding 1 locally.” massive (The worrying part about the above exchange is that some redditors couldn’t quite tell if these comments were genuine or not.) We seem to be abstracting further and further into run-time territory. But what if, instead of pushing our abstractions into run-time, we could pull them right back into ‘design’-time? That is just what the World Compiler achieves. It allows developers to contribute to and create immensely complex applications with just run-time dependency; the OS itself. one To join and compete within this World Compiler, a developer builds an Agent, an autonomous software program that captures and maps ( +1)-level requirements to -level requirements, giving these requirements to a completely new set of Agents within the network who will carry out their own compile-time mapping. n n Whenever a new build is kicked off, hundreds upon thousands of Agents within the World Compiler come together to an application, like one great big decentralised compiler spanning all layers of abstraction, from the gathering of application-specific requirements right down to opcode generation. collectively program, compile and return With such a system, it now becomes to pull garbage collection out of run-time and design it to pull out of run-time and design as part of the application itself. practical as part of the application itself… frameworks them We’ve been boxed into in an industry where a single compiler, fragmented languages and run-time abstractions are used to achieve an end-goal of automation. (and at the expense of performance), we have had to push a lot of overhead right . Out of necessity run-time into run-time But we’ve had it the wrong way around! We should be pushing the overhead into , and . compile-time using it to our advantage Rather than ‘talking’ at run-time to perform an automated , let’s ‘talk’ at compile-time to . service produce an automated product Let’s create a new industry where the languages and compilers and tools and paradigms are all and where every single niche is opened up to competition. decentralised yet compatible Let’s say goodbye to the gauntlet. Take the World Compiler for a spin . Request an invite to become part of it . here here To learn more about Code Valley, please visit , or follow the project on . https://codevalley.com twitter

HackerNoon Tech Stories Archive January 30th, 2017

Using ESLint for Encapsulation

@abdulnimeri
Abdul Nimeri

Development of Microservices - Problems and Solutions

@anil789
Anil Sharma

One More Analysis of GitHub and StackOverflow Data with Google BigQuery

@sAbakumoff
Sergey Abakumoff

Max Flow Algorithm in real life

@nasrserge
Serge Nasr

Coordinators: solving a problem you didn’t even know you had

@Zhuinden
Gabor Varadi

Use TypeScript Generics to Build a Simple Yet Strongly Typed Cache Utility

@pagalvin
Paul Galvin

What I learnt while trying to extract a domain from a monolith

@naoj_gior
Joan R

Gaming needs gamification

@jorgeschnura
Jorge Schnura

IT Central Station Is Riding the Peer Recommendation Wave in Enterprise Tech

@loukerner
Lou Kerner

Why is Product Hunt So Popular For Startup Launches?

@ktagriff
Katie Griffing

“What the #@$% was I thinking!?” How to write understandable code

@bertwagner
Bert Wagner

3 Ways To Gain User Trust in Mobile Apps

@whynotmatt
Matt Johnston

Selenium testing: a new hope

@aandryashin
Alexander Andryashin

Is AI driving humanity towards socialism?

@lucianodelcorro
Luciano Del Corro

“What can I do?” How Tech can #Resist

@noupside
Renee DiResta

Time Warner Cable is Not Neutral Toward CDN Traffic

@mikekijewski
Mike Kijewski

he Startup Scene at Brown

@albertdong_
Albert Dong

Running the run-time gauntlet

@codevalley42
codevalley

HackerNoon Tech Stories Archive January 30th, 2017

@abdulnimeriAbdul Nimeri

@anil789Anil Sharma

@sAbakumoffSergey Abakumoff

@nasrsergeSerge Nasr

@ZhuindenGabor Varadi

@pagalvinPaul Galvin

@naoj_giorJoan R

@jorgeschnuraJorge Schnura

@loukernerLou Kerner

@ktagriffKatie Griffing

@bertwagnerBert Wagner

@whynotmattMatt Johnston

@aandryashinAlexander Andryashin

@lucianodelcorroLuciano Del Corro

@noupsideRenee DiResta

@mikekijewskiMike Kijewski

@albertdong_Albert Dong

@codevalley42codevalley