Building Data Science Team

 From the book: Data Science Teams.pdf

A data-driven organization acquires, processes, and leverages data in a timely fashion to create efficiencies, iterate on and develop new products, and navigate the competitive landscape.

Author wrote also:

There are many ways to assess whether an organization is data driven. Some like to talk about how much data they generate. Others like to talk about the sophistication of data they use, or the process of internalizing data. I prefer to start by highlighting organizations that use data effectively.

See also: blog post on datascience: how-to-structure-data-science-team-key-models-and-roles

What is my IP-number in Azure

When you send a request to somewhere that uses your ip-number to whitelist, your ip number becomes important to know.
It is pretty simple when you do this on your laptop where you can open up a browser and find your outbound ip-number in Google. When you run your request within an Azure Web App which is running on an ASP, you might want to open up a console in Azure Portal and use the following PowerShell command:

(Get-AzWebApp -ResourceGroup <group_name> -name <app_name>).OutboundIpAddresses 

See also: find-outbound-ips

Think before going Microservices

The goal of microservices is to sufficiently decompose the application in order to facilitate agile application development and deployment.

The following is based on the book Microservices from Design to Deployment from NGINX. My goal is to know the difficaulties that this inevitable is bringing with in order to be prepared for.

The Drawbacks of Microservices

  1. One drawback is the name itself. The term microservice places excessive emphasis on service size. While small services are preferable, it’s important to remember that small services are a means to an end, and not the primary goal.
  2. Another major drawback of microservices is the complexity that arises from the fact that a microservices application is a distributed system. Developers need to choose and implement an inter-process communication mechanism based on either messaging or RPC. Moreover, they must also write code to handle partial failure, since the destination of a request might be slow or unavailable.

  3. Another challenge with microservices is the partitioned database architecture. Using distributed transactions is usually not an option, and not only because of the CAP theorem. They simply are not supported by many of today’s highly scalable NoSQL databases and messaging brokers. You end up having to use an eventual consistency-based approach, which is more challenging for developers.

  4. Testing a microservices application is also much more complex. A simple test class for a service
    would need to launch that service and any services that it depends upon, or at least configure stubs for those services.

  5. Another major challenge with the Microservices Architecture pattern is implementing
    changes that span multiple services. Fortunately, most changes typically impact only
    one service; multi-service changes that require coordination are relatively rare.

  6. Deploying a microservices-based application is also much more complex.

  7. Each service will have multiple runtime instances. That’s many more moving parts that
    need to be configured, deployed, scaled, and monitored. In addition, you will also need to
    implement a service discovery mechanism that enables a service to discover the locations
    (hosts and ports) of any other services it needs to communicate with.

Writing That Works

  • The foundations of effective business writing are simplicity and accuracy
  • emails: 
    • subjects are adequate
    • use positive tone
    • get to the point quickly and write only what’s relevant
    • etiquette is key
    • be explicit about your questions and requests
  • well-structured and focused presentations and speeches
    • engage your audience
    • finish with small memorable notes
    • use titles that builds anticipation
  • Drive people to action with clear plan and reports
    • purpose statement
    • facts
    • recommendations
    • purpose of the report should be clear and interesting
  • Speak to your reader’s desire and concerns
    • State what you want and offer your reasoning after the facts
    • demonstrate your competence with background information
    • grab reader’s attention 
  • Write a summary in bold
  • Edit and format your final product
    • cut out anything you think is not essential 
    • is the order correct
    • fact check
    • give yourself enough time between drafts, and have another person review 
    • format for smooth and appealing experience

Force HTTPS Rule

      <rule name="Force HTTPS" enabled="true">
        <match url="(.*)" ignoreCase="true"/>
          <add input="{HTTPS}" pattern="off"/>
        <action type="Redirect" url="https://{HTTP_HOST}/{R:1}"/>

Minify js and css files in Visual Studio 2012

Finally we got an integrated tool in VS2012 that does the jobin Solution Explorer:
Web Essentials
You can enable this tool using the Extensions And Updates from the TOOLS menu.

  1. First, right-click on the css file and from the Web Essentials context menu choose to Minify CSS Files. This will ensure that with every build it will generate the accompanying .min.css file too.
  2. Make sure you have the Web.Release.config beside your web.config
  3. In your .aspx or .master file put an if statement to figure out if this is running on your debug mode or release mode:
<% if (HttpContext.Current.IsDebuggingEnabled) { %>
<link href="/css/MyFile.css" rel="stylesheet" type="text/css"></link>
<%} else {%>
<link href="/css/MyFile.min.css" rel="stylesheet" type="text/css"></link>
<%} %>

Do more with less

You can do more with less by reducing your design to its essence, and solving for distractions,
not discoverability. Create a clean and purposeful experience by leaving only the most relevant
elements on screen so people can be immersed in the content.

  • Be great at something instead of mediocre at many things.
  • Put content before chrome.
  • Be visually focused and direct, letting people get immersed in what they love, and they will explore the rest.
  • Inspire confidence in users. 

Desktop browsers have quite a lot of chrome (menus, options, status bars, and so on) that is
only sometimes useful. Typically, however, users open a browser to see a webpage, not to
interact with the browser. Moving commands off the browser chrome and into the app bar or
into charms helps users focus on what they care about.

Copied from Windows 8 User Experience Guidelines

Favor Composition over Inheritance

Even though you “could” solve a problem by inheriting, see if there’s another option that doesn’t require you to inherit and compose your object of other helper object instead.
The above statement sounded so sophisticated when I read it first, that I wanted to put it in my blog. Yet there is something deep in my heart that tells me: don’t through away your years of experience and achievements gained by reusing objects through inheritance.

Original Thought

When 2 classes, let’s say Car and Vehicle implemented as follows:
    public class Vehicle
        public void Drive()
            Debug.WriteLine(“Vehicle is driving.”);
    public class Car : Vehicle
        public void Drive()
            Debug.WriteLine(“Car is driving.”);
By default the new implemented Drive method in the Car class hides the implementation in vehicle for any reference of Car type. So the following instances are expected:
    Vehicle v = new Vehicle();
    // output : Vehicle is driving.
    Car c = new Car();
    // output : Car is driving.
But the next one might cause unexpected situations when the construction occurs in a method far from calling the drive method.
    Vehicle x = new Car();
    // output : Vehicle is driving.
The output for the last call (Vehicle x) changes to “Car is driving.” when the Drive method in Vehicle is defined as virtual and in the Car defined as override.
Looks like the problem is solved.
But sometime I have a factory class creating some instances for me and I simply declare my variables and request for an instance:
Vehicle x = Factory.GetBMW();
This means that the place I use the instance might have no knowledge of how the instance is created and might not even know how they are implementing the Drive method.
For me, the ideal situation might be when I have a reference to a class of type Vehicle, I like it to drive as Vehicle. And when I want to have a Car that drives as a Car, I will define my reference as a Car.
Vehicle x = Factory.GetBMW();
Car y = Factory.GetBMW();
I can see that my point might not be important for BMW factory and they would rather to create a Car that drives the same way, no matter who is driving it.

Suggested Solution

The Composition over inheritance suggests that Car and vehicle does not inherit from each other. To make sure that they both are sharing functionality, the BMW class needs to implement both interfaces.
Let’s say that the following code is where we like to achieve:
    x.Drive();                  // output : Simply driving.
    (x as ICar).Drive();        // output : Car driving.
    (x as IVehicle).Drive();    // output : Vehicle driving.
To get there I have introduced three interfaces as follows:
    public interface IDrivable
        void Drive();
    public interface IVehicle : IDrivable
        void Drive();
    public interface ICar : IDrivable
        void Drive();
The BMW needs to implement them as it suites. This implementation has nothing to do with the way they are overloaded.
public class BMW : IVehicle, ICar
        void IVehicle.Drive()
            Debug.WriteLine(“Vehicle is driving.”);
        void ICar.Drive()
            Debug.WriteLine(“Car is driving.”);
        void IDrivable.Drive()
            Debug.WriteLine(“Simply driving.”);