Welcome to curated list of handpicked free online resources related to IT, cloud, Big Data, programming languages, Devops. Fresh news and community maintained list of links updated daily. Like what you see? [ Join our newsletter ]

Deploy serverless machine learning microservice with scikit-learn


Tags machine-learning aws serverless python

Patrick Michelberger created this tutorial in which we deploy a machine learning microservice using AWS Lambda, AWS API Gateway and scikit-learn.

Author starts with basic 3-class gradient boosted decision tree logistic regression model on iris data. This is not about quality of model, as for the purpose of the article it just needs to make predictions.

In this article author considers:

  • How to train a basic model
  • How to upload your model to AWS S3
  • How to create a Flask API
  • How to configure AWS Lambda & API Gateway
  • How to test the API locally
  • and how to deploy everything

Short and straight to the point tutorial for everybody starting with machine learning. Great!

[Read More]

BeamParticle -- polyglot dynamic programming engine


Tags programming erlang functional-programming elixir

Neeraj Sharma introduction into BeamParticle – an open source project built on top of the Erlang virtual machine (BEAM), which allows dynamic (re)programming in multiple programming languages. The project supports six different programming languages; namely: Erlang, Elixir, Java, Python, Efene, and PHP.

Key features include:

  • Supports 6 programming languages: Erlang, Elixir, Java-8, Python-3, Efene and PHP-5(subset).
  • Can run as a cluster (via Erlang distribution protocol)
  • Functions are dynamic and saving them instantly deploys them as HTTP POST API
  • Functions written in Erlang, Elixir, Efene and PHP can call other functions natively (with type conversions). Easily compile and deploy logic of code (functions) (across cluster when one exists) and archives them into a local
  • Key-Value store (powered by Google LevelDB).
  • System can create Jobs (or crons) which can be persisted to disk as well, so that they exist even after system restart.
  • HTTP(s) support with both HTTP 1.1 and HTTP 2.0 protocol.

The function compilation happens for the first time, while subsequent invocation uses the cached version to gain performance. Article then have many examples with codes for different languages and links to further resources. Very useful when you play with new API!

[Read More]

Journey into concurrent programming in Scala


Tags programming scala functional-programming

Justin LeFebvre interesting article about building a number of highly available Scala web services and making the most impact by modifying code to maximize CPU utilization on a per service basis. Enter the “scala.concurrent.Future ” type!

A Future is an object representing a value which may not have been computed yet but will be “soon”. An incredibly useful abstraction for dealing with concurrent computation.

What is interesting about Future:

  • Initial calling thread frees up that thread to be available to service subsequent requests
  • Useful when working with web servers
  • Almost always initialize a limited size thread pool
  • A callback to execute when the Future completes
  • Can be composed with other futures via any number of transformations

You can read more in the article together with example code. More advanced example project is also available. Nice!

[Read More]

Creating first Angular app. Implement routing


Tags mobile angular javascript apps

Monty Shokeen 3 part of tutorial series in which he demonstrates how to go about creating you first Angular application. This post is part of a series called Creating your first Angular app. This series will teach you how to create your first Angular app in a beginner friendly manner.

In this tutorial, we will be implementing routing in our app. This way, the users will be able to navigate from one component to another with ease.

You will learn how to:

  • Modify the application shell
  • Updating the app.module.ts file

In this series, author teaches readers who have never used Angular before how to create a basic Angular app. You will also find further links to previous articles which will teach you basics of ANgular application development. Good reading!

[Read More]

Amazing advantages of Golang nobody talks about


Tags golang programming devops

Kirill Rogovoy article in which he discusses why you should give Go a chance and where to start. This article is not about the main selling points of Golang that you usually see. These are some rather small but still significant features.

In the article he focuses on:

  • GoDoc
  • Static code analysis
  • Built-in testing and profiling framework
  • Race condition detection
  • Learning curve
  • Reflection
  • Opinionatedness
  • Culture

For example GoDoc is a static code analyzing tool that creates beautiful documentation pages straight out of your code. Also Golang heavily relies on static code analysis with many tools in this area. There are so many of them that there’s even an everything-included-kind-of project called gometalinter to compose them all into a single utility. Read it to learn more!

[Read More]

Why cryptography is much harder than software engineers think


Tags programming infosec devops

Andrew Mayo, senior system architect at 1E, wrote this intriguing article about ROCA vulnerability and how it raises some important issues about the design of secure cryptographic software. The vulnerability is not in this case an obvious coding error such as a buffer overflow, or the use of a poor quality random number generator.

In this case, vulnerability arose from what probably seemed like a reasonable software engineering decision. In summary, the researchers studied the statistical properties of a large sample of public keys. These are not normally easy to obtain, but the Estonian government had set up a public directory, associated with their national ID card. Since, by definition, these are public keys that’s a perfectly reasonable thing to do.

In theory, it’s almost impossible to derive the private key from the public key unless enormous amounts of computer time are expended.

Researchers analyzed the statistical properties of these public keys. They found that the keys were not truly random, as they should be. This meant that it was possible to derive the private key from the public key in days, rather than the expected thousands of years.

Article then explains and points to further resources to help with explanation how RSA algorithm requires that the prime numbers (which can contain thousands of digits) have certain additional properties and how keys are generated using rusted Platform Modules (TPMs). A TPM is a hardware device used to generate and manage keys securely. Good read!

[Read More]

GraphQL introduction at the REST-aurant


Tags restful apis nosql

Gregor intro into GraphQL. The article is accompanied with video presentation. If you ever wondered what GraphQL can do for you and you know a bit of JavaScript, this is an excellent post explaining basic concepts of GraphQL.

He explains basic concepts on the example of existing RESTful API for imaginary restaurant with 2 resources and concepts like:

  • Under and over fetching
  • GraphQL specification
  • How GraphQL API is built around a schema
  • How schema serves as contract between client and server
  • Persisted queries
  • Mutations
  • GraphQL subscriptions

Persisted queries are query strings stored with a unique ID in a key/value store. They are not part of the GraphQL specification but a common implementation detail. Good read!

[Read More]

Lambda architecture in Microsoft Azure


Tags software-architecture lambda azure serverless

Josh Lane interesting article on lambda architecture in Azure. His article focuses mainly on IoT specifics, but this design requires only a few minor tweaks to accommodate other non-IoT contexts. The concepts behind lambda architecture are straightforward and uncomplicated on their own.

Imagine we have a single logical stream of data against which we’d like to perform both just-in-time aggregation of narrow slices of the stream (“what’s the average value of X appearing in the stream over the last 15 seconds?”), as well as batch-oriented, resource-intensive queries that may require large subsets (or even all) of the data we’ve seen in the stream thus far (“what’s the average value of X across the entire stream history?”).

In his article he dives into 4 core key part of lambda:

  • A logical, streaming data source
  • A speed processing layer
  • A batch processing layer
  • A serving or presentation layer

Implementation for each layer is explained in detail. Author also describes why he wanted to use serverless architecture everywhere. You will also get access to schemes and example code accompanying this article. Excellent!

[Read More]

Event-driven architectures & AsyncAPI


Tags software-architecture event-driven messaging

Fran Mendez article about event-driven architecture. Engineers, often forget that APIs are not just HTTP APIs. API stands for “Application Programming Interface”. It’s exactly the “Interface” where author wants to focus.

In software engineering, high-quality architectures always go hand in hand with well-defined interfaces and responsibility boundaries.

Topics and messages are first-class citizens because they precisely represent services interfaces. AsyncAPI provides a specification that allows you to define message-driven APIs in a machine-readable format.

The spec is very similar to OpenAPI/Swagger so, if you’re familiar with them, AsyncAPI should be easy for you.

Use cases:

  • Documentation-first development
  • API testing
  • API management
  • Monitoring

You will also find further resources in the article.

[Read More]

RESTful communication between microservices can be perfectly fine


Tags microservices software-architecture restful

Daniel Westheide article in which he wants to clarify how the terms used should be understood and show that HTTP and REST for internal service communication can be perfectly fine. He also explains that choosing to do so has nothing to do with whether your services integrate synchronously or asynchronously –- and the latter question is what you should really be concerned with.

He argues, that when talking about synchronous versus asynchronous, one needs to consider:

  • Async IO (callbacks, futures, streams)
  • Asynchronous protocols (message passing, request-reply pattern)
  • Asynchronous service integration
  • Self-contained systems

In an ideal world, no communication whatsoever between your microservices should be necessary. And if it has to happen, it should be asynchronous. If you have to call other services in order to be able to serve a response to a request from a public client, this is really an architectural problem.

Author then argues that what you should really care about when designing your services is decoupling in time, which can be achieved or violated with both REST and message passing. Learn more in this interesting article.

[Read More]