Passed AZURE 70-533 Exam !!


Finally, I passed the Azure Exam 70-533 yesterday :-)

I never had anything to do with Azure before. But working with Azure and learning the techniques is really awesome and absolutely interesting!

I’ve been preparing for several weeks in order to get the things in my brain and to use Azure.

How did I prepare?

I’ve used several online sources and of course the free Azure subscription trial (30 days is fair enough for practicing).
Watch all the movies on Microsoft Virtual Academy (MVA), MSDN, Technet, YouTube, etc.
Then of course work through the Ebook (see below).
Use the documentation from the Azure homepage (Azure).
And last but not least – most important – practice, practice, practice, … with your Azure subscription.

My main sources:
Ebook “Exam Ref 70-533 Implementing Microsoft Azure Infrastructure Solutions”
Official Azure Documentation
Troy Hunt
Channel 9
Azure Friday (Channel 9)
Cloud Ranger YouTube VideosLook what others did…

And finally, register for the exam and plan it. Then you have a date and you have to get ready!
Exam 70-533 registration


My summary: AZURE ROCKS !!!




Oil Painting With Umber Underpainting


I started to paint with oil a while ago. I had a few lessons for my first painting (not this one here). After this I painted another one for my son’s bedroom. He likes to play with Duplo so I painted it.

In the following sections I’ll describe how I made the oil painting.

Besides, my teacher in Oil Painting is Guiseppe Fiore (Giuseppe FioreFacebook page of Guiseppe Fiore)

Basically I used just a few basic colors of Artisan Water Mixable Oil Colors. I chose water mixable be then I could paint at home.

  • Permanet Alizarin Crimson
  • French Ultramarin
  • Cadmium Yellow Pale Hue
  • Ivory Black
  • Titan White
  • Burnt Umber (for the underpainting)

I mixed all colors by myself and I used a big size 10 brush for the background and a small size 4 brush for the details.

1. Photo Transfer

First step was to transfer the photo of the Duplo to the canvas with pencil. Then I fixed the pencil drawing with a Acrylic Fixative.

Pencil drawing

Pencil drawing


2. Underpainting

The next step was to paint the underpainting with Burnt Umber values (mix it with water and white and black). Make sure that no pencil stroke shines through because it’ll be hard to cover them using i.e. yellow or red oil color. The best to achieve this is to mix it with lot of white so that you cover all the pencil strokes.
I did not do it as you can see below and that was a huge mistake!




3. Color Layers

The next and also final step is to paint the picture using your colors. You can add multiple layers if you want. I ended up painting 3 layers (and still the pencil strokes shine through the yellow color).

Color Layer

Color Layer – 1st Layer

Color Layer - 2nd Layer

Color Layer – 2nd Layer

Color Layer - 3rd Layer

Color Layer – 3rd Layer


4. Lessons Learned

Definitely, use white and black and a lot of umber to cover all your pencil strokes. I tried to “refurbish” the yellow area. The result is not perfect but it’s Ok.

Paint the next layer only if the previous one is really almost dry. Otherwise you would “move” the color of the previous layer.

And finally, don’t use too much color for the first layers. With each layer you can add more color. Start with a thin color layer and become thicker then.

"Refurbish" Layer

“Refurbish” Layer



For efficient 3D object selection in my OpenGL world, I decided to implement a version of Kd-tree that meets my requirements.

Selection was more than 10 times faster than before (brute force). Specially when the number of selectable 3D objects increased 😉


A* Path-Finding Algorithm


The next routing algorithm I implemented was A*.

The A* – as well as Dijkstra – needs a priority queue in order to work through the graph and find the shortest path.

In worst case the time complexity of A* is exponential.
But if the following conditions holds, then the time complexity is polynomial – i.e. O(n), O(n * n), O(n * n * n).
Condition : | h(n) – h'(n) | < O(log * h(n))
h(n) : estimated distance
h'(n) : exact remaining distance

The cost function that you use to decide which node to visit next is: f(n) = g(n) + h(n).
g(n) : known cost from the start node to n
h(n) : heuristic to estimate cost from n to destination node

Finding the right function h(n) can be very difficult.
For simplicity I used the “haversine” distance between node n and the destination node.
You can also use more sophisticated functions that also consider traffic, slope, etc.

Since A* is a general case of Dijkstra you may thing that the time complexity is pretty much the same as that of Dijkstra (note: if h(0) is 0 then A* = Dijkstra).
But given a good heuristic A* can be much faster because a lot of nodes will not be expanded out.
It is important that h(n) computes in O(1) time – if not then A* could also be worse than Dijkstra.