CodeIsGo.com

Cloud architect Forrest Brazeal wrote intriguing article in which he considers shortcomings and advantages of DynamoDB. He interviewed a number of engineers and developers about their experiences with the database service. As great as DynamoDB is – and as rousing as its success stories are – it has also left plenty of failed implementations in its wake.

The First Law of DynamoDB: Assume that a DynamoDB implementation will be harder, not easier, than using a relational database that you already know.

Some of the points debated in his post:

• DynamoDB is simple – until it doesn’t scale
• DynamoDB is scalable – until it isn’t simple
• Hot keys “gotcha”

I recommend also follow link to a blog post mentioned in the article on pointing that DynamoDB is not necessarily suited to datasets that have a mix of hot and cold records. “The Million Dollar Engineering Problem”. Great read, enjoy!

Derick Bailey wrote a blog post about some interesting features in JavaScript ES7 which you can use right now. It seems everything is changing in JavaScript – even the naming of releases has changed, with years marking the language version.

He argues that it’s not always obvious, but there is a short list of features from ES2016+ (ES7 and beyond) that I believe every JavaScript developer should be using very soon, if not immediately.

Article then focuses on:

• Object rest / spread properties
• Observables
• Async functions

Even if the feature definition is not 100% complete, there is enough value and enough support to make it both easy and safe to use. Code examples are provided together with instructions how to know when it’s safe to use new JavaScript features.

Article on KDnuggets™ about how Apache Arrow provides a new way to exchange and visualize data at unprecedented speed and scale. Despite the fact that interactive visualization of large data sets on the web has traditionally been impractical.

Imagine a future where “Minority Report” style data visualizations run in every web browser.

The Apache Arrow ecosystem, including the first open source layers for improving JavaScript performance, is starting doing exactly that. An approach taken i remote rendering: the server sends geometry commands to the client, and the client turns those into viewable pixels by leveraging the client’s standard web browser and its local access to a client-side GPU.

Remote rendering experiences over typical web architectures built on JSON hits two key bottlenecks:

• Networking clogged by large file sizes
• CPU and memory-intensive data serialization

A big win for the file size is using a columnar format. Apache Arrow was designed to eliminate the overhead of serialization by providing a standard way of representing columnar data for in-memory processing. Follow the link to learn more.

Jan Olbrich wrote article about his and his team experience with understanding topics like concurrency and parallelism. Together you will learn how to program concurrently.

Article then reads about:

• Synchronous vs Asynchronous
• Concurrency vs Parallelism
• Mechanisms for concurrency
• Options to control concurrency

Article is extensive, e.g. when describing concurrency it dives into: process, thread, dispatch queues, operation queues, run loops, lightweight routine. The same goes for options to control concurrency, e.g. article describes: priority inversion, priority inheritance, lock, spinlock, mutex, semaphore…

There are so many options to do concurrent programming and this posts just scratches the surface. Excellent read!

Colin Charles published extensive comparison between MySQL vs. MariaDB (including Percona Server for MySQL). His goal was to evaluate, at a higher level, MySQL, MariaDB and Percona Server for MySQL side-by-side to better inform the decision making process. It is largely an unofficial response to published comments from the MariaDB Corporation.

Article then compares

• Open community
• Core engine comparison and what is shared
• General features comparison
• Extensibility
• Analytics
• High availability
• Security

and more, e.g. supporting ecosystem and tools, enterprise database compatibility. Seems like there is a healthy competition in the MySQL ecosystem.

Gerrit Grunwald wrote pos about how easy it is to use Java SE and JavaFX to create mobile applications that run on iOS and Android devices in the cloud – without the need to learn a lot of different platforms.

For this project, author makes use of the Oracle Application Container Cloud service, which provides preconfigured containers that run Java SE applications.

Article then follows with detailed information:

• About app idea
• Server application requirements
• Code for creating a simple REST endpoint
• The Mobile Application in JavaFX using framework, called Gluon
• Deployment to Oracle Application Container Cloud service

And much more. For limited time you can also get coupon to experience Oracle Cloud for free worth $300. Sweet!

Jonathan Baldie short tutorial addressing speed of Redis connection. Connecting to Redis via Unix sockets is usually faster than connecting via TCP/IP.

That’s because in general, Unix sockets have much less overhead. They’re essentially just files that Unix-based systems can read. The downside of that being that only local connections are possible.

A 14% speed difference is significant and we should take advantage of this even when using Docker.

The most systems based on Docker are set up to connect to Redis via Docker’s own TCP bridge networking. So how can we use Unix sockets? We can take advantage of shareable Docker volumes so we can use Unix sockets even in containers environment.

We can use the busybox image for this volume container because this container won’t actually be doing anything other than holding the volume. We also can use volumes_from option to extra the same volume from the busybox container. Good article with detailed code examples and explanation.

Rupak Ganguly wrote neat post about the process of continuous integration and deployment (CI/CD) of serverless application – which can be really challenging. In this post, author takes a deep look at the end-to-end workflow of automating a CI/CD process for a serverless application via CircleCI.

Article describes using serverless frameworks and also covers in depth (among others):

• Defining the CI/CD process
• Creating an app with testable code
• Preparing the app for automation
• Integrating with a CI/CD toolchain
• Advanced deployment patterns

It also covers Creating an AWS IAM user and configuring CircleCI with AWS credentials. Plenty of code examples, screen grabs and explanations. In real-life enterprise scenarios, there’s a lot of complexity involved in deploying an application. There are concerns about redundancy, high-availability, versioning & rollback, A/B testing and incremental rollouts. Good read!

James Griffiths post on Angular pipes. Angular, the underlying front-end development framework used by Ionic, provides developers with a feature known as pipes which allows data values to be transformed within an application’s template view prior to being displayed.

Over the course of his tutorial he takes you through using the following Angular pipes:

• DatePipe
• i18nSelect

Following from these he’ll then create 2 custom pipes which will allow the following data transformations to take place:

• Return a random array element
• Return a random generated, unique string value with a name spliced into that at select intervals

All pipes in Angular make use of a single method – transform. Both example code and installation instructions will help you to understand pipes in Angular. Start building your own pipes now. Good read.

Prasanna Ranganathan from Flipkart published article about building a world-class e-commerce discovery experience through search. The dynamic nature of e-commerce poses unique challenges - stock units, availability, pricing, catalog data, etc. can all change at a very high rate and the system needs to keep up with the latest data lest the customer be disappointed.

Challenge: Processing all the data updates (10K per sec on average) on a continuous basis.

Stack they built their solution on:

• HBASE
• Storm + Kafka
• Redis
• Solr

Their real-time distributed stream processing framework of choice is Storm. Storm, coupled with Kafka, has a thriving user community not to mention the backing of the Apache foundation. Good read with supporting resources and charts.