Not so much sensational fact in general, but for me  it actually was. And that’s because it’s written in Python. I don’t want to create a scandal, but I’ve never used Python before today.

In fact, curly-bracketed programming languages has been where I felt home for really a long while now, and I was just scared to step out my syntactic comfort zone: C, C++, Java, PHP and Javascript are different in many ways, but they all push the same buttons in our muscle-memory.

[java]
for ( i = 0; i<10; i++ ) {
...
if ( i > 5) {
…
}
else {
…
}
}
[/java]

Except for some dollar sign, this small piece of code can belong to any of the above mentioned languages. That’s a small piece of evidence: use of braces, fundamental keywords, use of semicolons, all contribute to identify the C-based programming languages .
It took to me a considerable leap of faith and bravery to make the jump and have the first look on what’s beyond the line, exploring Python for the first time. But then, I was really impressed.

Exciting stuff about Python

Syntax expressiveness remains as high as C-based languages even if blocks are not delimited by curly braces. Actually, code is unbelievably clear even if blocks are simply NOT delimited.

Where’s the magic? Indentation.

Python takes indentation so bloody seriously that the interpreter will refuse to execute the code if not properly indented. Yes, badly indented code is not tidy code, untidy code is bad to read, bad to read code is less useful code for people. Hence Python won’t execute.

It took so long for computer science to understand that the scarce resource in programming is the human resource, and languages should be optimized for people, not for the CPU.

Syntactic correctness may be enough for a computer, but it’s right that a language optimized for the people requires more than that. And Python is really designed around this concept.

But there’s more than just style-aware syntax constraints: fully and natively supports OOP principles (you should have a look to what the string class can do). However, Imperative and Functional styles are viable as well in Python.

With such an enormous amount of bindings and libraries, you could use this language to build really anything. Included Web, Network, GTK and 3D applications.

Python stays to Perl as Java stays to C.

Things I look forward to find in Python world

I don’t know if it was Django web framework, but still error messages were not so crystal clear. Even PHP prints more useful statements. However, full stack traces always appeared.

I also would like a good debugging environment, for example I’ll have a look at Eclipse based projects good enough to show me what’s inside variables and so on, like I do in Java.

Then, my browser arrived at Vineet Gupta’s article (extremely informative), and I got interested in project voldemort: a key-value store provider written in Java by Linkedin engineers, on the inspiration of Amazon Dynamo.

Tephlon is not aimed to support cluster storage, and it has a synchronous approach to storage. It’s written in PHP and, in a typical setup, the same PHP process who serves the page needs to get the data stored.

So there’s an ocean of different prerequisites between Tephlon and Voldemort, even if evolving from the one to the other should pretty easy for a web application, since the aim is the same (providing persistent key-value stores).

Disregard that, I was too curious to set up some little basic performance tests.

Let’s say a bit more of project-voldemort. This distributed key-value store  is really powerful. And, as the name hints, there’s a lot of magic it’s capable of:

• Gossip based state propagation
• Partitioning and replication
• cluster rebalancing
• versioning (vector clocks)
• pluggable storage engines and serializers
• pluggable nio socket implementation

Setting it up in an Eclipse environment is as easy as installing GIT plugin from standard upload sites which come with latest Eclipse IDE, cloning their git repository, and execute the build.xml ant script.

Then open a terminal, navigate through your Eclipse workspace directories and find voldemort project directory. It contains a bin/ folder. Now execute the following.

 bin/voldemort-server.sh config/single_node_cluster &

Next step is to open voldemort.examples.ClientExample class (fast class search in Eclipse: ctrl+T), right click on it and execute as java application.

What I did next is writing a bit more code in ClientExample.java, to see better how fast this thing is.

So here are some results on my little laptop (2.0GHz core 2 duo, 2GB memory):

RW (GET & SET 1000000 entries)
total time (s)	: 835.361
avg optime (s):	8.3536183E-4
longest optime (s):	0.214
shortest optime (s):	0.0

Quite amazing!

Yesterday I bought a Kingston V+ SSD (128GB), pretty much one of the fastest solid state drives on the market (among others of the same size).

Now, SSDs are great, I don’t regret buying it because it’s really really fast. But here’s a relevant thing that I noticed which did not appear in any of the reviews around the internet and I would like people to know.

Premise: I installed it  in my samsung Q70 laptop (2 years old, 2.0GHz core 2 duo).

The Thermal issue

This is what you read from all technical reviews about how good SSDs are and what enormous advantages they represent:

Hard disk IO is nowadays the worst bottleneck for our evoluted super fast CPUs. Modern processors have to put themselves to sleep for relatively enormous amount of time, waiting for disk IO to happen.

And that’s definitely true, it’s such a pity our processor could run a heavy encoding algorithm with a crazy bandwidth, but it needs to face the miserable 25-30MB/s of spinning platters hard disks.

But what happens if hard disks suddenly become 10 times faster?
Automatic installers will go very fast, moving files here and there is awesome, booting takes 1/3 of the time. That’s true. On the other hand, your CPU average operating  temperature will definitely raise. Let’s see why this thermal issue makes dramatically perfect sense:

Let’s imagine we need to uncompress 1GB compressed file. Your archiving application will probably perform a tight cycle over each chunk of file:

1. read from arhive (disk IO),
2. uncompress/dictionary lookup/CRC (CPU computing)
3. write to uncompressed file (disk IO)

In the HDD case

We just said that CPU operations are way faster than disk IOs. Let’s guess computing a data chunk is just even 2 orders of magnitude faster than reading or writing it to disk.

Ratio: CPU time / Disk IO time = 10/2*10^3 = 0,02

This translates like: with all given approximations, CPU is actually computing 2% of the time.

In the SSD case

In my case, with SSD adoption I achieved almost exactly 10x disk IO speed. Given the loose hypothesys of the above paragraph, this means that CPU is faster than disk IO just of 1 order of magnitude.

Ratio: CPU time / Disk IO = 10/2*10^2 = 0,2

With disk IO speed boost of SSD, the CPU is busy for the 20% of the time.

Conclusion

With 10 times faster disk IO, we expect that during a simple file uncompression (running any autoinstaller) CPU is computing 10 times more intensely. And this will impact on the thermal balance of your computer. Quite much.

Of course handling of compressed files is just an example. As far as now, I noticed this behaviour coming visibly up also after rebooting.
This si really something that you don’t ever think about before you face it. That is also because SSDs keep pretty fresh because of their power efficiency. Thus seems so far from the excited mind of  the pre-buyer’s that he’ll occur in excessive heat issues.

In my specific test looks like the CPU is behaving like a real bottleneck uncompressing a big LZMA archive (7z). CPU was stuck to 100% on BOTH cores during the process (which – ok – was happening really fast).

Tephlon - Relax, we'll do the plumbery

Tephlon is my new personal project. It’s a library for PHP and written in PHP.

Tephlon provides a persistence layer to your code such that your variables, strings, objects will still be available in the next HTTP request.

It provides a core persistence engine, which takes care of handling and maintaining caching records, and a set of “data types” classes which build the “transparent” persistence abstraction.

It’s still quite new, at the time of writing we’re at version v1_0-pre2 , and the core API is still subject to changes, but the results of performance test and whole architecture are very very promising.

UPDATE: Released version v1_0 generally available for download! I also made a guide for integration with Codeigniter

Basically the reasons always fall into being a matter of :

• Data consistency, think about databases, you hopefully want to update the date of birth of a person just in the ‘people’ table, and not into every table who references a person.
• Mantainability, think about programming, you will not want to mention the presence of a steering wheel and pedals when you are asked to describe what a Lamborghini supercar is.
  Maybe you will mention these basic common characteristics  if somebody asks you what a car is. Then, when they ask you about Lamborghini you will just mention it’s a car and the person will understand it has steering wheel and all the rest.

All these extremely good reasons not to repeat yourself in informatics derive from the fact that whenever needed, the one who’s best to do operations in cycle without errors is the computer, not the programmer.

Advice

Even if DRY mindset is very encouraged while producing new code, it’s also true that obtaining very good DRYness at first shot is very uncommon. In fact it is a process that will put yourself using precious time, energies and concentration just into refactoring old code.
Useless to say that this is maybe the best investment in future you can do, and it will pay back more and more as the project grows.

DRY approach to CSS

Said that DRY is necessary and achievable at different degrees through a process of progressive code refactoring, let’s see how it applies to this very unconventional language: CSS.
In other environments like C++ and Java we can leverage the explicit inheritance at a class level. For example we can say in Java:

Class Lamborghini extends Car {
   public Lamborghini (..) {
      ...
   }
}

This means that every lamborghini object we create, an instance of the class Lamborghini will be created and it will always inherit every characteristic (methods and fields) of the class Car.

...
// myLambo is also a Car object!
Lamborghini myLambo = new Lamborghini(..);
...

In CSS this does not really happen in such a clean way. There absolutely is inheritance, and it’s very useful. Just that every object (xhtml DOM element) is able to choose its parents. As many as it wants.
Here comes an example.

/* Declaring a CSS class into stylesheet */
.footer_block {
 ..
}
.category_posts_block extends .footer_block { // No way, man.
  ...
}

And in the xhtml document..

/* Instantiating an xhtml node (read: object) into xhtml DOM */
<div class="footer_block category_posts_block">
  ...
</div>

This inversion of control has very likely been chosen to remark the secondary role that the style needs to have towards the content. Indeed, in the three layers model

Notice how absolutely none of these designs includes Helvetica. Notice also the amount of  ”Swissness” into these designs thanks to the use of typography, the intense and precise use of grids to structure the information and underline its semantics.

Full screen & enjoy.

Thanks a lot, progressivered.com!

If you don’t set the right encoding parameters, PNG images are not going to be rendered the same way across every browser. This is a well known problem.

What was much less known is the solution:

- in Photoshop, turn on proof colors (view -> proof colors)
- make sure your proof setup is set to “monitor rgb” (view -> proof setup -> monitor rgb)
- when you save for web, make sure you do 24 bit png, interlacing OFF, and uncheck convert to srgb

via: swiss-miss

save

Now, CSS is an awckwardly false-easy language. Especially coming from OOP (object oriented programming) it sometimes makes you really confused and frustrated.
But you don’t understand what’s the problem with it as long as you are into doing CSS (in fact you just feel dumb..). You really realize the problem just and only when you go back to OOP after using CSS: it’s wonderland! No surprise it feels so cozy to be back in a place in which:

• classes correspond exactly to the real-world concept of classes,
• inheritance is a thing that you have some decisional power about,
• if it compiles, you can assume it will behave in a predictable way in all the platforms it’s supposed to run on,
• you use the same language to define the appearence and the behaviour of the output,
• your final output is the result of computation of one known machine that you can state the technical specs of. In CSS you are really not going to have control on the nature of the interpreter of your code (the browser).
• You can declare constants, yes, I didn’t say variables. Coming from CSS you will watch them really with different eyes.

But in a further analysis, it’s not so true that all the OOP experience is useless when coming to CSS. It’s almsost the opposite.
Back to software engineering lessons, they  tought us to keep in mind wrote with fire to our mind a set of principles to stick to whenever approaching a project. One of these is certainly modularity.  Let’s see how to leverage this principle while using CSS.

Applying Modularity concept to CSS

There’s at least a couple of orthogonal ways in which the process of modularization can be used in CSS. The first is breaking down the stylesheet into different files, representing the what I call “aspects” of our final layout. For example, in a typical scenario we’ll have:

• reset.css
  With this file we reset the properties of default elements to a known value that will be common to all browsers, regardless of browser’s built in default paddings, margins, etc.  This will strike a large part of the cross browser incompatibilities, which are still today the major pain of who develops for the web. Remember to reset also typographic elements like paragraph, headings, blockquotes, table, lists, etc.
  As a rule of thumb, be sure that you have no standard elements out of this file, or dually that all the elements declared in other stylesheets are classes or ids.
• ie6.css/ie7.css
  Unfortunately sometimes you will also need to deal with cross broswer incompatibilities that need a conditional comment and a specific stylesheet for internet explorer 6 or 7 (or both).
  
• grid.css
  Here we define the classes which define the width in terms of multiple of a grid column width. In order to define a proper grid with proper gutters (implemented with margins in css), please refer for example to 960 grid system project (which by the way includes an excelent reset.css).
• structure.css
  This contains the declarations of the divs that partition the page’s real estate. If you worked well in grid.css you don’t need to position them anywhere, just declare here the heights (optional) , look and feel (background images, borders), vertical margins and other styling related properties.
• typography.css
  While generic properties of unstyled text should be specified into reset.css, here instead you define  all the deltas between standard elements and class/id specific elements.

The second layer of modularity that you can add to your stylesheets  is giving a precise hierarchy to the content. Really doesn’t matter which hierarchy and in which order you walk by it, just choose one. In the following example I chose a visual hierarchy, and I walked by it from top to down.
Please be sure also to have a tidy and consistent use of comments in support to this. It helps always a lot.

/*
 * Header
 */

#header h2 {
 color: #333;
 font-weight: 600;
 font-size: 2em;
}
#headline p{
 font-size:1.2em;
}
/* End Header */

/*
 * Sidebar
 */
#sidebar h1{
 font-size: 1.3em;
}
.side-block p{
 color: #555;
 ...
}
/* end Sidebar */

/*
 * Footer
 */
#sidebar h1{
 font-size: 1.3em;
}
.side-block p{
 color: #555;
 ...
}
/* end Footer */

save