update

11 files changed, 167 insertions, 8 deletions

diff --git a/.jekyll-metadata b/.jekyll-metadata
index 65ec8bd..354cdb3 100644
--- a/.jekyll-metadata
+++ b/.jekyll-metadata
diff --git a/Makefile b/Makefile
index a001990..02db7c8 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@ clean:
         -rm -Rf _site/
 
 run: clean
-        bundle exec jekyll serve --incremental
+        bundle exec jekyll serve --incremental --drafts
 
 publish:
         git add .
diff --git a/_drafts/2018-08-05-the-bullshit-web-revisited.md b/_drafts/2018-08-05-the-bullshit-web-revisited.md
new file mode 100644
index 0000000..6f3faa7
--- /dev/null
+++ b/_drafts/2018-08-05-the-bullshit-web-revisited.md
@@ -0,0 +1,78 @@
+---
+layout: post
+title: The Bullshit Web revisited
+description: The bullshit web revisited
+---
+
+**Table of content**
+
+- [Initial thoughts](#initial-thoughts)
+- [Front-end frameworks](#front-end-frameworks)
+- [Obsolescence to the rescue](#obsolescence-to-the-rescue)
+- [Speed of development trumps code quality](#speed-of-development-trumps-code-quality)
+- [Load times of most popular websites](#load-times-of-most-popular-websites)
+
+## Initial thoughts
+
+I have recently read an amazing essay by Nick Heer on the web called [The Bullshit Web](https://pxlnv.com/blog/bullshit-web/) and it got me thinking about the future of the web as it is today.
+
+I really try to stray away from frond-end development as much as possible. The reason is nowhere close to me having any bad opinions but having to work with clients on visual stuff drains me to the point of sheer horror.
+
+I have observed silently the progress that was made in this field because I thought things will get better with time. I was so wrong. So wrong. Not only that things got extremely complicated to work with, the whole stack because so massive even simple pages have insanely large footprint.
+
+The Bullshit Web essay concentrates mostly on page sizes and AMP but I would like to address tooling and technologies for development in this post.
+
+Currently we have two types of websites:
+
+- informational websites,
+- web applications.
+
+The problem that occurs is that more and more websites are treathed as web application where simple web page would suffice. And this in my opinion adds insult to the injury.
+
+We talk about progressive web applications, AMP, and other technologies that are solving the problems of bandwidth, usability and in general making web faster but in reality this rarely gets applied in real life scenarios. Most of the time this are just demos on conferences.
+
+## Front-end frameworks
+
+I am not of of those purists that denies usage of JavaScript frameworks or SASS but there are limits to where this obsession should go. In order to use these technologies properly one should ask himself where exactly they are needed and not use them like hammer for nails.
+
+Whenever I need to do front-end UI I usually check specification before embarking on journey of coding. And most of the times I really don't need frameworks. Most of the code I need to write in JavaScript is done in couple of hundred lines of code and does exactly what specification requires. And developer that will be working on this code after me doesn't need to learn new framework, tooling, etc. Just pure vanilla JavaScript. In all of my years as a developer I can count on fingers on my one hand when I used some sort of a framework. And even in this exceptions we later rewrote code to vanilla JavaScript because maintaining complex code was just to time consuming.
+
+There is an argument to be made for using frameworks in cases where multiple people are working a project and code must be easily transferable and on-boarding process must be swift. But in reality this is just another bullshit excuse to stick with what is "cool". I stand by Function over Form. And this also conflicts with the notion that frameworks never change. Frameworks evolve and adapt to market needs and most of the times get massive and hard to maintain. And we get stuck with massive codebase that is developed with many hacks and workarounds, because framework didn't support some feature at the time of development. I personally hate workarounds and being a smart-ass that intentionally makes code harder to read. I find frameworks similar to the story about Cain and Abel. Either you get murdered or framework gets. Most of the times framework dies and leaves legacy nobody would want.
+
+Huge strives have been made to address this problem and many fantastic frameworks emerged and some of theme are absolutely amazing. But there needs to be a strong case for using them in a project. We should never blindly use them regardless of the problem we are trying to solve.
+
+I must admit that tooling around front-end is getting better and better and we are slowly getting there but there still is a long road ahead.
+
+## Obsolescence to the rescue
+
+We can all agree that frameworks or libraries usually are there to fill the gap what currently is widely supported by the standard. Most of this so called frameworks are just libraries that unifies browser compatibility. The prime example of this is jQuery. There was a time almost everybody was using jQuery. But through time HTML5 specs were updated to include ideas from jQuery and this filled the browser compatibility gap. There is this awesome article [The Rise and Fall of jQuery](https://www.evolutionjobs.com/uk/media/the-rise-and-fall-of-jquery-117981/).
+
+Don't get me wrong. Yes, I dislike jQuery but I find it indispensable and without it our web would be very different. For the worst in my opinion. It was a huge stepping stone for front-end development. But there comes a time where technologies get obsolete and standards catch up with the requirements of the field.
+
+
+
+## Speed of development trumps code quality
+
+
+Num of request
+
+
+## Load times of most popular websites
+
+| URL                | Num of requests | Transfered | Finish  | DOMContentLoaded | Load   |
+| ------------------ | --------------- | ---------- | ------- | ---------------- | ------ |
+| cnn.com            | 134             | 3.22 MB    | 4.7 s   | 575 ms           | 3.60 s |
+| youtube.com        | 61              | 1.8 MB     | 5.13 s  | 1.78 s           | 1.97   |
+| wikipedia.com      | 11              | 64.5 KB    | 642 ms  | 531 ms           | 573 ms |
+| reddit.com         | 177             | 12.9 MB    | 7.65 MB | 2.03 s           | 3.74 s |
+| amamzon.com        | 278             | 8.0 MB     | 5.20 s  | 1.15s            | 2.99 s |
+| twitter.com        | 202             | 5.1 MB     | 23.48 s | 3.20 s           | 4.55 s |
+| twitch.tv          | 177             | 4.4 MB     | 5.08 s  | 579 ms           | 798 ms |
+| microsoft.com      | 77              | 1.1 MB     | 3.96 s  | 1.01 s           | 1.26 s |
+| huffingtonpost.com | 134             | 2.9 MB     | 2.30 s  | 789 ms           | 1.47 s |
+| nytimes.com        | 240             | 2.9 MB     | 4.64 s  | 1.30 s           | 4.29 s |
+| foxnews.com        | 195             | 1.7 MB     | 4.42 s  | 1.25 s           | 3.86 s |
+| theguardian.com    | 203             | 2.8 MB     | 2.75 s  | 784 ms           | 2.43 s |
+| bbc.com            | 127             | 1.3 MB     | 3.44 s  | 1.24 s           | 2.65 s |
+
+Chrome Browser Developer tools was used to measure load times.
diff --git a/_posts/2015-11-10-software-development-pitfalls.md b/_posts/2015-11-10-software-development-pitfalls.md
index 862ae08..69aa77d 100644
--- a/_posts/2015-11-10-software-development-pitfalls.md
+++ b/_posts/2015-11-10-software-development-pitfalls.md
@@ -4,6 +4,20 @@ title: Software development and my favorite pitfalls
 description: Couple of observations regarding project management.
 ---
 
+**Table of content**
+
+- [Initial thoughts](#initial-thoughts)
+- [Ping emails](#ping-emails)
+- [Everybody is a project manager](#everybody-is-a-project-manager)
+- [We are never wrong](#we-are-never-wrong)
+- [Micromanaging](#micromanaging)
+- [Human contact - no need for it!](#human-contact---no-need-for-it)
+- [MVP is killing innovation](#mvp-is-killing-innovation)
+- [Pressure wasteland](#pressure-wasteland)
+- [Conclusion](#conclusion)
+
+## Initial thoughts
+
 Over the years I had privilege to work on some very excited projects both in software development field and also in electronics field and every experience taught me some invaluable lessons about how NOT TO approach development. And through this post I will try to point out some of the absurd outdated techniques I find the most annoying and damaging during a development cycle. There will be swearing because this topic really gets on my nerves and I never coherently tried to explain them in writing. So if I get heated up please bare with me :)
 
 As new methods of project management are emerging, underlaying processes still stay old and outdated. This is mainly because we as people are unable to completely shift away from this approaches.
diff --git a/_posts/2017-01-12-gce-aws-docker-and-why-i-choose-classic-vms-and-digitalocean.md b/_posts/2017-01-12-gce-aws-docker-and-why-i-choose-classic-vms-and-digitalocean.md
index 3f202a8..17714b1 100644
--- a/_posts/2017-01-12-gce-aws-docker-and-why-i-choose-classic-vms-and-digitalocean.md
+++ b/_posts/2017-01-12-gce-aws-docker-and-why-i-choose-classic-vms-and-digitalocean.md
@@ -4,6 +4,13 @@ title: GCE, AWS, Docker and why I choose classic VM’s and DigitalOcean for my
 description: Reasons why I choose DigitalOcean for my project
 ---
 
+**Table of content**
+
+- [Docker tools and complexity that comes with it](#docker-tools-and-complexity-that-comes-with-it)
+- [Lack of real life examples of Docker in action](#lack-of-real-life-examples-of-docker-in-action)
+- [Ease of deployment](#ease-of-deployment)
+- [Where to go from here](#where-to-go-from-here)
+
 I have been developing a product for the past few months and one of product’s requirement is the ability to automatically scale quickly on system’s demand.
 
 As most of you probably know system design is much more important then actual code that will drive the product. And this was my main concern when developing this product. I have read anything I could get my hands on about Docker as it was hyped so much in media for the past two years. At a first glance Docker was ideal fit for this platform. But then as I started to seriously experiment with it and developing around it several problems occurred. Well, it would be unfair to call them problems but lets say drawbacks when developing rapidly.
diff --git a/_posts/2017-03-07-golang-profiling-simplified.md b/_posts/2017-03-07-golang-profiling-simplified.md
index f74c7b2..5b9f6ed 100644
--- a/_posts/2017-03-07-golang-profiling-simplified.md
+++ b/_posts/2017-03-07-golang-profiling-simplified.md
@@ -4,6 +4,15 @@ title: Golang profiling simplified
 description: Golang profiling made easy
 ---
 
+**Table of content**
+
+- [Where are my pprof files?](#where-are-my-pprof-files)
+- [Why is my cpu profile empty?](#why-is-my-cpu-profile-empty)
+- [Profiling](#profiling)
+  - [Memory profiling](#memory-profiling)
+  - [CPU profiling](#cpu-profiling)
+  - [Generating profiling reports](#generating-profiling-reports)
+
 Many posts have been written regarding profiling in Golang and I haven’t found proper tutorial regarding this. Almost all of them are missing some part of important information and it gets pretty frustrating when you have a deadline and are not finding simple distilled solution.
 
 Nevertheless, after searching and experimenting I have found a solution that works for me and probably should also for you.
diff --git a/_posts/2017-04-17-what-i-ve-learned-developing-ad-server.md b/_posts/2017-04-17-what-i-ve-learned-developing-ad-server.md
index 772fb98..5de4cf5 100644
--- a/_posts/2017-04-17-what-i-ve-learned-developing-ad-server.md
+++ b/_posts/2017-04-17-what-i-ve-learned-developing-ad-server.md
@@ -4,6 +4,15 @@ title: What I've learned developing ad server
 description: Lessons I learned developing contextual ad server
 ---
 
+**Table of content**
+
+- [Aggregate everything](#aggregate-everything)
+- [Measure everything](#measure-everything)
+- [Cache control is your friend](#cache-control-is-your-friend)
+- [Learn NGINX](#learn-nginx)
+- [Use Redis/Memcached](#use-redismemcached)
+- [Conclusion](#conclusion)
+
 For the past year and half I have been developing native advertising server that contextually matches ads and displays them in different template forms on variety of websites. This project grew from serving thousands of ads per day to millions.
 
 The system is made from couple of core components:
diff --git a/_posts/2017-04-21-profiling-python-web-applications-with-visual-tools.md b/_posts/2017-04-21-profiling-python-web-applications-with-visual-tools.md
index 5bbfe48..ca5dbdd 100644
--- a/_posts/2017-04-21-profiling-python-web-applications-with-visual-tools.md
+++ b/_posts/2017-04-21-profiling-python-web-applications-with-visual-tools.md
@@ -4,6 +4,12 @@ title: Profiling Python web applications with visual tools
 description: Missing link when debugging and profiling python web applications
 ---
 
+**Table of content**
+
+- [Simple web-service](#simple-web-service)
+- [Visualize profile](#visualize-profile)
+  - [Update 2017-04-22](#update-2017-04-22)
+
 I have been profiling my software with KCachegrind for a long time now and I was missing this option when I am developing API's or other web services. I always knew that this is possible but never really took the time and dive into it.
 
 Before we begin there are some requirements. We will need to:
diff --git a/_posts/2017-08-11-simple-iot-application.md b/_posts/2017-08-11-simple-iot-application.md
index f2bcabc..5774b66 100644
--- a/_posts/2017-08-11-simple-iot-application.md
+++ b/_posts/2017-08-11-simple-iot-application.md
@@ -4,6 +4,19 @@ title: Simple IOT application supported by real-time monitoring and data history
 description: Develop simple IOT application with Arduino MKR1000 and Python
 ---
 
+**Table of content**
+
+- [Initial thoughts](#initial-thoughts)
+- [Simple Python API](#simple-python-api)
+  - [Basic web application](#basic-web-application)
+  - [Web application security](#web-application-security)
+  - [Simple API for writing data-points](#simple-api-for-writing-data-points)
+- [Sending data to API with Arduino MKR1000](#sending-data-to-api-with-arduino-mkr1000)
+- [Data visualization](#data-visualization)
+- [Conclusion](#conclusion)
+
+## Initial thoughts
+
 I have been developing these kind of application for the better part of my last 5 years and people keep asking me how to approach developing such application and I will give a try explaining it here.
 
 IOT applications are really no different than any other kind of applications. We have data that needs to be collected and visualized in some form of tables or charts. The main difference here is that most of the times these data is collected by some kind of device foreign to developer that mainly operates in web domain. But fear not, it's not that different than writing some JavaScript.
diff --git a/_posts/2018-01-16-using-digitalocean-spaces-object-storage-with-fuse.md b/_posts/2018-01-16-using-digitalocean-spaces-object-storage-with-fuse.md
index 7442956..6b89e2b 100644
--- a/_posts/2018-01-16-using-digitalocean-spaces-object-storage-with-fuse.md
+++ b/_posts/2018-01-16-using-digitalocean-spaces-object-storage-with-fuse.md
@@ -4,17 +4,26 @@ title:  Using DigitalOcean Spaces Object Storage with FUSE
 description: Using DigitalOcean Spaces Object Storage with FUSE
 ---
 
+**Table of content**
+
+- [Is it possible to use them as a mounted drive with FUSE?](#is-it-possible-to-use-them-as-a-mounted-drive-with-fuse)
+- [Will the performance degrade over time and over different sizes of objects?](#will-the-performance-degrade-over-time-and-over-different-sizes-of-objects)
+        - [Measurement experiment 1: File copy](#measurement-experiment-1-file-copy)
+        - [Measurement experiment 2: SQLite performanse](#measurement-experiment-2-sqlite-performanse)
+- [Can storage be mounted on multiple machines at the same time and be writable?](#can-storage-be-mounted-on-multiple-machines-at-the-same-time-and-be-writable)
+- [Observations and conslusion](#observations-and-conslusion)
+
 Couple of months ago [DigitalOcean](https://www.digitalocean.com) introduced new product called [Spaces](https://blog.digitalocean.com/introducing-spaces-object-storage/) which is Object Storage very similar to Amazon's S3. This really peaked my interest, because this was something I was missing and even the thought of going over the internet for such functionality was in no interest to me. Also in fashion with their previous pricing this also is very cheap and pricing page is a no-brainer compared to AWS or GCE. [Prices are clearly and precisely defined and outlined](https://www.digitalocean.com/pricing/). You must love them for that :)
 
 ### Initial requirements
 
-* [Is it possible to use them as a mounted drive with FUSE?](#fuse) (tl;dr YES)
-* [Will the performance degrade over time and over different sizes of objects?](#performanse) (tl;dr NO&YES)
-* [Can storage be mounted on multiple machines at the same time and be writable?](#multiuser) (tl;dr YES)
+* Is it possible to use them as a mounted drive with FUSE? (tl;dr YES)
+* Will the performance degrade over time and over different sizes of objects? (tl;dr NO&YES)
+* Can storage be mounted on multiple machines at the same time and be writable? (tl;dr YES)
 
 > Let me be clear. This scripts I use are made just for benchmarking and are not intended to be used in real-life situations. Besides that, I am looking into using this approaches but adding caching service in front of it and then dumping everything as an object to storage. This could potentially be some interesting post of itself. But in case you would need real-time data without eventual consistency please take this scripts as they are: not usable in such situations.
 
-## <a name="fuse"></a>Is it possible to use them as a mounted drive with FUSE?
+## Is it possible to use them as a mounted drive with FUSE?
 
 Well, actually they can be used in such manor. Because they are similar to [AWS S3](https://aws.amazon.com/s3/) many tools are available and you can find many articles and [Stackoverflow items](https://stackoverflow.com/search?q=s3+fuse).
 
@@ -67,7 +76,7 @@ Additional information on FUSE:
 * [Github project page for s3fs](https://github.com/s3fs-fuse/s3fs-fuse)
 * [FUSE - Filesystem in Userspace](https://en.wikipedia.org/wiki/Filesystem_in_Userspace)
 
-## <a name="performanse"></a>Will the performance degrade over time and over different sizes of objects?
+## Will the performance degrade over time and over different sizes of objects?
 
 For this task I didn't want to just read and write text files or uploading images. I actually wanted to figure out if using something like SQlite is viable in this case.
 
@@ -249,7 +258,7 @@ You can download [raw result here](/files/sqlite-benchmarks.tsv). And again, the
 })();
 </script>
 
-## <a name="multiuser"></a>Can storage be mounted on multiple machines at the same time and be writable?
+## Can storage be mounted on multiple machines at the same time and be writable?
 
 Well, this one didn't take long to test. And the answer is **YES**. I mounted space on both machines and measured same performance on both machines. But because file is downloaded before write and then uploaded on complete there could potentially be problems is another process is trying to access the same file.
 
diff --git a/assets/site.css b/assets/site.css
index 6e3da46..2c65044 100644
--- a/assets/site.css
+++ b/assets/site.css
@@ -17,7 +17,7 @@ main,
 footer,
 nav,
 header {
-        max-width: 800px;
+        max-width: 700px;
         margin: 0 auto;
 }
 
@@ -99,6 +99,20 @@ blockquote {
         padding: 5px 0 10px 20px;
 }
 
+table {
+        border: 2px solid #f1f1f1;
+        width: 100%;
+        border-collapse: collapse;
+        border-spacing: 0;
+}
+
+table th,
+table td {
+        border: 2px solid #f1f1f1;
+        text-align: left;
+        padding: 5px 10px;
+}
+
 .highlighter-rouge {
         border: 1px solid #ddd;
         padding: 0 15px;