I just wish to reiterate my gratitude towards all the contributors to the project. The ones who specifically worked on this awesome release, those who made it all possible, are: Matthew Ellison, Dominik Kellner, David Kirkendall, Damián Nohales, calve, Jonathan Huot, Roman Redkovich and of course the one and the only Frank Sachsenheim, whose role was pivotal to this release.

If you want to get in touch, I am @nicolaiarocci on Twitter.

• PostAsync() supports bulk inserts
• DeleteAsync() supports bulk deletes
• GetAsync() has a softDelete option to include soft-deleted documents with query results
• GetAsync() has a rawQuery option to pass raw Eve queries to the server
• BearerAuthenticator class adds support for Bearer Token authentication

Several fixes made it into this release and, most importantly, I switched to portable Profile259 which offers support for the following platforms: Xamarin.iOS, Xamarin.Android, WinPhone 8.1, Windows 8, .NET 4.5+. Yes, that means no more support for .NET 4.0. See the changelog for details.

Eve.NET v0.2 is on NuGet so you can install it either from Visual Studio or with the Package Manager console. Enjoy!

If you want to get in touch, I am @nicolaiarocci on Twitter.

How it works

First, you need to set the ApplicatioName. This is also going to be the folder where your cache will reside. Depending on the host OS the location of this folder might be different. On Windows it would be something like C:\ProgramData\<ApplicationName>\SimpleObjectCache.

Let’s instantiate SimpleObjectCache so we can use it:

Now we create a Person, then store it into our cache.

As we insert an object into the cache we can also set its expiration date:

Inserting an object with an already existing key, which we just did, will overwrite the previous object with the same key. Retrieving the object is a matter of providing its key:

To remove the object from the cache we use the Invalidate method:

Bulk inserts are also possible:

Note that we just set the Tom and Mike expiration date to yesterday. Now let’s add John again. For him however, we set an expiration date which is bigger than Tom’s and Mike’s:

The Vacuum method removes expired objects from the cache. So Tom and Mike, whose dates are passed, are going to be purged by the following command:

Now let’s get all the available Person objects from the cache.

Since Tom and Mike are gone, we only got one object back, and that’s our very own little John.

Installation

SimpleObjectCache is on NuGet. Run the following command on the Package Manager Console:

Or install via the NuGet Package Manager in Visual Studio.

Wrapping it up

We needed a simple cache that we could use as a component of our cross-platform storage system (more on that in a future post). We wanted the cache to also run seamlessly on the old .NET 4.0 framework. Unfortunately Akavache, to which this project is blatantly inspired, does not run on .NET4, so I decided to roll out my own simplified alternative. This project also offered a great occasion get my feet wet with bait-and-switch portable classes and a few other interesting challenges.

Currently supported platforms are iOS and Android (Xamarin) and .NET Framework versions 4.0 and .NET 4.5+.

If you want to get in touch, I am @nicolaiarocci on Twitter.

Eve’s schema definitions are full of features, but can take a good amount of time to create when dealing with lots of complex resources. From our experience, it’s often helpful to describe an endpoint in JSON before creating it as an Eve schema. This allows you to make quick decisions about the structure of your entities without spending time moving schema code around. This is where EveGenie comes in.

EveGenie saves time by creating a ready to use Python Eve schema from a very simple JSON representation of a set of resources.

Interested? Good! Matt Tucker (@ultimateboy) has a getting started with EveGenie article up for you, so make sure to check it out.

Work on v0.7, which will include MongoDB Aggregation Framework support (docs) and many other new features, continues steadily.

But what is Swagger, and why is it useful to your RESTful API? With a Swagger-enabled API you can get interactive documentation, client SDK generation and discoverability, all for free. From Swagger website:

Swagger is a simple yet powerful representation of your RESTful API. With the largest ecosystem of API tooling on the planet, thousands of developers are supporting Swagger in almost every modern programming language and deployment environment. With a Swagger-enabled API, you get interactive documentation, client SDK generation and discoverability.

When Eve-Swagger is installed and properly configured your Eve API exposes a special /api-docs endpoint which returns a 100% swagger-compliant JSON response. This JSON can then be processed by the swagger tools like Swagger UI and Swagger Editor. Here we can appreciate Swagger UI providing API documentation out of the box (click to zoom):

Like most Eve extensions Eve-Swagger comes as a standard Flask Blueprint and, as such, using it is very simple:

Once the blueprint has been registered all you have to do is add a SWAGGER_INFO node to your settings. It maps to a swagger infoObject and contains some simple, human readable information. The extension will also scan your endpoint settings to figure out the API graph and document it. Of course, in order to not to clutter your launch script, you could (and probably should) set SWAGGER_INFO in your configuration file.

Installation is super easy:

This is just version 0.0.2 so many parts might still be moving, but you are encouraged to start using it right away. Also if you appreciate this extension please let me know by either starring it on GitHub or with a tweet or email, so I will know that I should really try hard and allocate more time to this project. As always, feel free to contribute via pull request!

If you want to get in touch, I am @nicolaiarocci on Twitter.

All things considered, I would dare to claim that Cerberus is battle tested to death. This is, in fact, one reason why I believe that the time for a canonical and stable release has come. Another reason is that next release is a major one. It brings a ton of important new features along with very significant code refactoring and a redesigned, powerful API. Third, next release breaks backward compatibility, and we want to signal that in the version number.

So next Cerberus release will be 1.0. If you have been following the development this will come as no surprise, as a Release Candidate has been out for a while. As a Cerberus user you will want to take the plunge and upgrade to 1.0 because well, it is just too cool to be true. If new to Cerberus you will also want to adopt 1.0 right away, for the same reason. If you are new however, make sure you get the basics covered before reading further. By the way, at latest PyCon Italy I gave a talk on Cerberus which also included a preview of several 1.0 features. You can check the slides to get a general idea of the tool, its usage, and upcoming features.

Let’s now look at some of the relevant features and changes introduced with Cerberus 1.0. For a (mostly) accurate list of changes and new features, have a look at the changelog.

Transformation and normalization

Big news in the normalization department. Similar to validated(), the new normalized() method returns a normalized copy of a document without validating it.

Renaming of Fields

You can now define a field to be renamed before any further processing.

To let a callable rename a field or arbitrary fields, you can define a handler for renaming. If the constraint is a string, it points to a custom method.

If the constraint is an iterable, the value is processed through that chain.

Purging Unknown Fields

After renaming, unknown fields will be purged if the purge_unknown property of a Validator instance is True.

You can set the property per keyword-argument upon initialization or as rule for subdocuments like allow_unknown. The default is False.

Default Values

You can set default values for missing fields in the document by using the default rule.

You can also define a default setter callable to set the default value dynamically. The callable gets called with the current (sub)document as the only argument. If the constraint is a string, it points to a custom method.

Value Coercion

Coercion has been introduced with 0.9. It allows you to apply a callable to a value before the document is validated. The return value of the callable replaces the new value in the document. This can be used to convert values or sanitize data before it is validated.

If the constraint is an iterable, the value is processed through that chain.

Please note that coerce kicks in with validate(), not with normalized().

Schema Validation

This is another area the is seeing a lot of changes and new, powerful things.

Registries

Schema registries are awesome if your schemas shall include references to themselves (recursion) and if they contain a lot of reused parts and are supposed to be serialized. There are two default registries in the cerberus module namespace. You can use schema_registry to store definitions for schemas which can later be re-used:

And you can extend rules_set_registry with rules-sets which can then be referenced in validation schemas:

Schema Constraints in docstrings

Validation schemas themselves are validated when passed to the validator or a new set of rules is set for a document’s field. A SchemaError is raised when an invalid validation schema is encountered.

Now you can provide constraints as literal Python expression in the docstring of the rule’s implementing method to validate the arguments given in a schema for that rule. Either the docstring contains solely the literal or the literal is placed at the bottom of the docstring preceded by the following sentence: The rule's arguments are validated against this schema.

The example below is comes directly from Cerberus’ own test suite:

Validation Rules

forbidden

Opposite to allowed, this new rule validates if a value is any but one of the defined values:

min, max

Up to 0.9 you could only use min and max to compare numeric types. Now they define minimum and maximum values allowed for any types that implement comparison operators.

keyschema

For better consistency, the propertyschema rule has been renamed to keyschema. This is the counterpart to valueschema and validates the keys of a dict.

type

Data type validation now also supports the binary type.

Breaking Changes

This is a major release which breaks backward compatibility in several ways. Don’t worry, these changes are for the better. However, if you are upgrading, then you should really take the time to read the list of changes in the changelog and consider their impact on your codebase, especially so if you have custom validators sitting around. For your convenience, there are also some upgrade notes available.

Acknowledgements

Cerberus 1.0 would not exist in its current form without the incredible work done by Frank “funkyfuture” Sachsenheim. After his initial, timid, set of v0.9 contributions, Frank went on a rage. He really adopted the project and went on touching on every aspect of it: documentation, new features, proposal, fixes, refactoring, ticket triaging, you-name-it. His efforts have been instrumental in taking the project to the next level. As a token of appreciation for his work, I’m tagging this release with the funkyfuture codename.

Of course he was not alone. Other contributors were Matthew Ellison, Dominik Kellner, Damián Nohales, calve, Roman Redkovich. And then are all the other people who helped by opening tickets and spreading the word around. Thank you all, folks.

Closing notes

Cerberus 1.0 is an important milestone. I consider the API to be reasonably stable and, once it is released, I plan to let it settle down for a while. Release Candidate will stay out for a couple more weeks, which is ideal for you to experiment a little bit before the final release.

If you are a Eve user you probably see the potential that new Cerberus can offer to your RESTful API, especially in the normalization department. Don’t get too excited though as I do not plan on immediately adding Cerberus 1.0 to Eve. Next Eve release (v0.7), which is also upcoming, will be focused on MongoDB Aggregation Framework and other things. That is more than enough for a major release. I am targeting the following release (v0.8) for Cerberus 1.0 support.

So, have fun with New Cerberus. As usual, please report any issue on the ticket system.

If you want to get in touch, I am @nicolaiarocci on Twitter.

A partire dal 9 maggio 2016 sono introdotti nuovi controlli sui file trasmessi al Sistema di Interscambio. Per consentire il necessario adeguamento al nuovo regime di verifiche, fino al 31 luglio 2016 il mancato superamento di uno o più di questi nuovi controlli non comporterà lo scarto del file ma solo una segnalazione che verrà riportata all’interno della Ricevuta di consegna o della Notifica di mancata consegna. Dal 1 agosto 2016 i file che non dovessero superare uno o più di questi controlli verranno scartati.

Se per ora i nuovi controlli non sono vincolanti, lo saranno a partire dal 1 agosto. Poiché si tratta di una serie di convalide sui conteggi consiglio di passare alla versione 0.2.1 al più presto, così da verificare che in effetti le vostre fatture elettroniche siano in linea con le aspettative della PA: potreste avere qualche sorpresa.

Nel nostro caso, per esempio, abbiamo dovuto prendere atto che gli importi imponibili relativi alle aliquote IVA, così come le corrispondenti imposte, devono essere indicati al lordo degli eventuali sconti generali del documento, pena il rifiuto dello stesso da parte del sistema di interscambio. Date una occhiata al changelog per l’elenco completo delle novità.

Voglio aggiungere un commento sulle modalità di pubblicazione degli aggiornamenti tecnici da parte di Agenzia Entrate/Sogei. Sebbene siano dotati di data e numero di versione, questi sono da considerarsi, ad essere buoni, puramente indicativi. Per esempio l’attuale versione 1.2 dell’elenco controlli è stata aggiornata “silenziosamente” un paio di giorni dopo la pubblicazione (hanno aggiunto una tolleranza di 1 Euro al controllo 00422). Così lo sviluppatore incauto che si limiti a controllare la data e il numero di versione del documento rischia di vedersi respingere fatture per lui del tutto corrette, a meno che non di prenda la briga di verificare, riga per riga, la corrispondenza tra la documentazione in suo possesso e quella disponibile sul sito in quel momento. Chiaramente in PA non hanno idea di cosa sia il Semantic Versioning.

Un ringraziamento al mio collega Stefano Gardini. Il suo nome non compare nelle commit ma, quando si stratta di fatturazione e contabilità, è come se ci fosse.

If you want to get in touch, I am @nicolaiarocci on Twitter.

This post is not much (or only) about my talks or performance, but hopefully more around the different communities I got a chance to interact with.

PyCon Sette, Florence

PyCon Italy is like home to me. Here, back in 2012, I gave my first Python talk which also happened to be my first English talk ever. Back then Italy was hosting EuroPython 2012, the general assembly of the European Python community, so we had people flying in from all over the continent (and beyond). And I was there all alone, a .NET guy who knew no one, pretending to teach pythonistas how to properly build a REST API powered by MongoDB and Flask. Talk about putting myself out of my comfort zone. That talk was important for many reasons, I won’t go into them, suffice to say that, without it, the Eve project would not exist now.

The following years I went back with more talks. After the three booming EuroPython years we saw the number of PyCon attendees drop from the 700s to the about 150 at PyCon Cinque. Following that first post-EuroPython event however the numbers started to raise. Fast. So fast, in fact, that this year we ended up celebrating the all-time high of 575 attendees. An impressive result, as it almost tops EuroPython numbers. We owe a lot to the skill, expertise and braveness of the PyCon Italy organizers. They are simply awesome, and tireless. Such a result, however, also a is a testimony of how strong, vibrant and resilient the Italian community around Python is.

This year I was there to give my first Cerberus talk. The room was packed full, everything went smoothly (at least from my perspective) and when all was done and said I was left with the impression that the project was well received. My only regret is that I totally forgot to submit the talk for the English track. I also took part in the Python Web Framework Royal Rumble, a panel in which Django, Flask, Pyramid and TurboGear champions were to fight each other. I was defending the Flask flag, and it was a lot of fun.

The Italian Python community is cozy and friendly as always, stronger than ever. PyCon in Florence keeps improving its already high standard. My only suggestion would be to reverse the English/Italian tracks ratio. I would go for an all-English conference with just one track for Italian language. I am sure a lot of guests would flock in from nearby countries. I mean who would not want to visit Florence, and Tuscany Plus, many pythonistas already have very fond memories from the Italian EuroPython years and I am sure they would love to come back.

PiterPy, St. Petersburg

PiterPy is an important and very well organized Python event which gathers attendees not only from St. Petersburg, but also from other Russian cities and nearby countries.

I was invited by the conference organizers to talk about project Eve. I was honoured, excited and curious to meet fellow pythonistas from the Eastern Europe. Other headliners were Chris Ewing, Gael Varoquaux, Hynek Schlawack, Simone Soldateschi and Fabio Natali. As you can tell, we all have different backgrounds and specialize on different things, as it should be when you want to present your audience with different interesting aspects of your stack of choice.

I did my Eve talk and then even managed to sneak in lightening talk on Cerberus. I was also interviewed by Vladimir Filonov (I think the recording is due out soon) and to my surprise the interview was not on my open source activity but rather on the Italian Python community. It turns out that in Russia they care a lot about the community, and they are eager to know more about other Python communities scattered all around Europe. Freaking awesome, if you ask me.

Organizers were professional and friendly all the time, letting me feel comfortable right from the start. In fact I was just off the plane when I met with Maxim Klymyshyn, who took me from the Airport to the conference location. The venue itself (Original Sokos Olympia Garden, conveniently located close to St. Petersburg’s city center) was probably one of the best, if not the best, conference venue I ever been at. And what about the attendees? They were very welcoming with their international guests and language barrier was not an issue as many of them speak very good English (often better than mine). Be warned however, when given the opportunity they will not hesitate to challenge the unwary speaker with the hardest of questions. I am told (by the attendees themselves) that this is in fact a trait of the Russian people. They won’t be shy when they have something to say. As a speaker, I really appreciated the attitude!

The day after the conference a cultural trip to Catherine Palace in Pushkin was planned for both speakers and attendees. That was terrific. Should you go to St. Petersburg, on a business trip or just as a tourist, make sure you visit Catherine Palace. You won’t regret it.

My eternal gratitude goes to Vladimir Shulyak and Dmitry Nazarov for taking me and my new buddy Chris Ewing out for diner and then on a super nice walk around the city center. Special thanks to Serge Matveenko, Diana Lyubavskaya and the rest of the team for inviting us and, most importantly, for putting up such a great event. I am sure PiterPy will soon become a relevant event within the international community.

Western Europe MVP Community Day, Rome

This was my first time as a MVP to a Microsoft event. Not only that. This was actually a MVP-only event and I was there to give a talk to experienced MVPs who, for the most part, have been in the program for years. Kind of intimidating, although I was reassured by the fact that my proposal had been voted by the MVP community itself.

Like at my first Python conference years ago I knew no one there, not personally at least, so it took some balls win my shyness and introduce myself to the first person I recognized, that one being Alessandro Del Sole, a long time MVP veteran. He and his pals were super nice and only moments after introducing myself to them I was already feeling part of the community. A very empowering feeling. Later during the evening and even more so the following day, at the conference, I got to meet and know a lot of new friends, all very knowledgeable in their craft, which is awesome.

I would say that the focus of the event was about Microsoft’s new openness toward other stacks and communities, which also helped in making me feel comfortable. I gave my Real Life .NET Cross Platform talk, with good feedback. SimpleCache, which was used as an example project and wasn’t really the main topic, got a lot of interest so I may actually release it on NuGet soon (blog post coming). My highlight for the event though, would be Karen Juhl keynote during which I suddenly realized that a picture of me, along with quotes from one of my articles, was being shown on stage. It took me a few seconds to realize what was going on, as it was totally unexpected. That was crazy, and mesmerizing. Later, when I got to talk with Karen, I learned that that very same slide has been used at several MVP events across Europe. So exciting!

The conference was closed by an Open Source Communities Panel, to which I was invited as a member of multiple communities.

The next day I was at the OpenDomus.net event, where I got a chance to repeat my cross platform talk (this time in Italian), and then to give a live demo of Ubuntu Bash on Windows. That one was interesting, and surprising I think, for many attendees. A few days later, with Lorenzo Barbieri, we recorded a Best of Build 2016 episode on the same topic (link below).

TecHeroes Interlude

April and March were also the months in which I and Lorenzo Barbieri recorded and released a few MSDN TecHeroes Italy episodes:

• Vim for Visual Studio
• Python Tools for Visual Studio
• CoderDojo Coding Clubs for Kids
• Real Life .NET Cross Platform
• Bash on Ubuntu on Windows (actually a Best of Build episode)

Wrapping it up

As I mentioned at the OSS panel I am lucky to have an active role in more than one community and to work every day with diverse technologies. Now, most of the times the problems tackled by these stacks are, in fact, the same. Besides the obvious differences in semantics, what really changes and is most interesting to me is the approach, the path if you will, taken by each individual stack. For me, being exposed to multiple approaches and therefore getting a chance to appreciate the differences, the pros and cons of each one (which tend to vary depending on the situation at hand) has been invaluable. I could (and probably should) fill a blog post with the things I learned working on Python that I am now using, with profit, in C#. And vice-versa.

And what about the communities? Different communities, again, expose me to different cultures. That is a good thing. Being rooted into a community is great but being active in multiple communities is even better, in essence for the same reasons you’d want to become a polyglot programmer.

So my invite is to get involved once again, no matter how active and fit you are into a stack and its community. Try something totally new, even if it doesn’t really sound like something immediately useful to you. Because you know, cross-pollination is a good thing. And you get to party twice the time, too.

If you want to get in touch, I am @nicolaiarocci on Twitter.

Work on v0.7 is also ongoing. It will include new features such as support for the MongoDB Aggregation Framework (docs) and a few breaking changes, so you might want to check it out in advance.

Special thanks to Arnau Orriols, Cyril Bonnard, Hamdy, Luca Di Gaspero, Manquer, Nick Park, Patrick Decat, Prayag Verma, Ralph Smith, Stratos Gerakakis, Valerie Coffman and Wei Guan who contributed to this release.

This came totally unexpected. Especially so considering that during the last few years I have been splitting my time between Microsoft and other open source technologies. My public work has mostly been on Python and MongoDB. Yes I also released .NET open source projects in the meantime (more are coming soon) and yes, I wrote a few articles here and on the MSDN Blog, attended Microsoft events and did interviews. But really, I did not expect these activities to have an impact. This is probably why only a couple minutes from learning about the award I was suffering Impostor Syndrome symptoms.

Now however, as I ponder on the whole issue a little bit, I start to realise how this could probably make (at least some sort of) sense. New Microsoft has been eager to catalyse attention and interest from the open source community and, in a broader sense, from people not yet accustomed to the brand. In light of this, people who have been active in communities other than Microsoft’s and have also been exposed to different technologies, mindsets and approaches to common IT problems could indeed offer some value. Or at least that’s how I am reading it right now.

So a new chapter is unfolding in my twenty-five years long love/hate relationship with Microsoft. It is my intent to live up to this award, for which I am very grateful.

How do I setup endpoints without any binding to a data entity, just connected to a custom method?

They would like to call something like /mycustomendpoint and get the response from a method they have defined somewhere in the Python sources. The standard endpoint-entity mapping provided by Eve covers 90% of their needs, but sometimes they just need endpoints that have nothing to do with data entities.

This is very easy to achieve. I’m writing it down so I can point people to this post in the future.

Eve is Flask

Eve is a Flask application and I really mean it since it is, in fact, a Flask subclass. Eve adds out-of-the-box RESTful capabilities to the Flask micro-framework. Most of the time you will be happy with just Eve’s own features but remember, the full Flask (and Werkzeug at a lower level) features set is also part of your arsenal.

Whatever you can do with Flask, you can do with Eve

So yes, of course you can easily set some functions to be invoked when a custom endpoint is hit with a request. The following snippet is a slightly modified version of Flask’s very own Quickstart tutorial:

By decorating the hello_world method with the route decorator we added a new endpoint to the application. Each time a request to /hello comes in, it will be routed to our custom method. Of course the regular API endpoints (either defined in settings.py, passed as a dict at launch, or registered live by calling the register_resource method) will also be available.

If you have an Eve authentication class securing regular API endpoints, you can apply it to your custom endpoint too. Just add a requires_auth decorator:

Say that you saved the above snippet as run.py and also have your RESTful endpoints properly configured. Launch the script:

You can now point your browser to http://localhost:5000/hello/ and enjoy the application greeting. Or you can consume any other configured API endpoint.

As all of Flask features are at your fingertips you might as well opt for registering a blueprint, which is what the awesome Eve-Docs extension is doing in order to provide a static HTML /docs endpoint on top of any Eve powered API.

Update: v0.1.6 has also been released.

Collection rules

First up is the new set of anyof, allof, noneof and oneof validation rules. anyof allows you to list multiple sets of rules to validate against. The field will be considered valid if it validates against one set in the list. For example, to verify that a property is a number between 0 and 10 or 100 and 110, you could do the following:

>>> schema = {
...     'prop1': {
...         'type': 'number',
...         'anyof': [
...             {'min': 0, 'max': 10}, 
...             {'min': 100, 'max': 110}
...         
...         ]
...     }
... }

>>> doc = {'prop1': 5}
>>> v.validate(document, schema)
True

>>> doc = {'prop1': 105}
>>> v.validate(document, schema)
True

>>> doc = {'prop1': 55}
>>> v.validate(document, schema)
False

allof is the same as anyof, except that all rule collections in the list must validate. Same pattern applies to noneof (no rule in collection must validate) and oneof (only one rule in collection must validate).

Type coercion

Type coercion allows you to apply a callable to a value before any other validators run. The return value of the callable replaces the new value in the document. This can be used to convert values or sanitize data before it is validated.

>>> v = Validator({'amount': {'type': 'integer'}})
>>> v.validate({'amount': '1'})
False

>>> v = Validator({
...     'amount': {
...         'type': 'integer', 
...         'coerce': int
...     }
... })
>>> v.validate({'amount': '1'})
True
>>> v.document
{'amount': 1}

>>> to_bool = lambda v: v.lower() in ['true', '1']
>>> v = Validator({
...     'flag': {
...         'type': 'boolean', 
...         'coerce': to_bool
...     }
... })
>>> v.validate({'flag': 'true'})
True

>>> v.document
{'flag': True}

Properties (keys) validation

propertyschema is the counterpart to valueschema (also new, it replaces the now deprecated keyschema) and validates the keys of a dictionary.

>>> schema = 'a_dict': {
...     'type': 'dict', 
...     'propertyschema': {
...         'type': 'string', 
...         'regex': '[a-z]+'
...     }
... }

>>> document = {'a_dict': {'key': 'value'}}
>>> v.validate(document, schema)
True

>>> document = {'a_dict': {'KEY': 'value'}}
>>> v.validate(document, schema)
False

List of types

The type rule can now be a list of types, to allow for different type of values for the field.

>>> v = Validator({
...     'quotes': {
...         'type': ['string', 'list']
...     }
... })

>>> v.validate({'quotes': 'Hello world!'})
True

>>> v.validate({'quotes': ['Do not disturb my circles!', 
...                        'Heureka!']})
True

>>> v = Validator({
...     'quotes': {
...         'type': ['string', 'list'], 
...         'schema': {'type': 'string'}
...     }
... })

>>> v.validate({'quotes': 'Hello world!'})
True 

>>> v.validate({'quotes': [1, 'Heureka!']})
False

>>> v.errors
{'quotes': {0: 'must be of string type'}}

And there is more so make sure you check the changelog before upgrading. No breaking changes but there’s at least one deprecation, as mentioned.

Fun fact: Cerberus is currently getting 3x the downloads of his sister project Eve, the REST API Framework for which the tool was originally conceived. Interesting if you consider that Eve is featuring 10x the GitHub stars. Fun, but not really surprising since Cerberus probably has a broader audience.

Special thanks to Frank Sachsenheim, Tobias Betz, Brett and C.D. Clark III for their valuable contributions to this release.

If you want to get in touch, I am @nicolaiarocci on Twitter.

On my flight back to Italy I jotted down a few thoughts on the topic and then, this morning, the first thing that comes up on my newsfeed is Monolith First by Martin Fowler. Stunning, because the essay content totally resonates with my own notes, so much that it would perfectly serve as a recap for them.

Going directly to a microservices architecture is risky, so consider building a monolithic system first. Split to microservices when, and if, you need it.

And also, perhaps more importantly:

A more common approach is to start with a monolith and gradually peel off microservices at the edges. Such an approach can leave a substantial monolith at the heart of the microservices architecture, but with most new development occurring in the microservices while the monolith is relatively quiescent.

I find it fascinating that there is a chance that my notes and the essay were written (by astral coincidence?) in the very same minutes.

In the beginning, there was no inheritance and no composition, only code. And the code was unwieldy, repetitive, blocky, unhappy, verbose, and tired. Copy and Paste were the primary mechanisms of code reuse. Procedures and functions were rare, newfangled gadgets viewed with suspicion. Calling a procedure was expensive! Separating pieces of code from the main logic caused confusion! It was a Dark Time.

Il progetto Fattura Elettronica Open Source si è arricchito di un nuovo strumento: Web Services. Il namespace FatturaElettronicaPA.WebServices raccoglie una serie di client C# che consentono di consultare i Web Service per la Fattura Elettronica messi a disposizione dalla Pubblica Amministrazione.

Sono disegnati in maniera da esporre tutti la stessa interfaccia ed essere al tempo stesso semplici e leggeri. Al momento lavorano in modalità sincrona ma l’obiettivo è di renderli tutti asincroni.

Come usare i Web Service

Prendiamo per esempio il Web Service che consente di convalidare un Codice Univoco di Fatturazione e recuperare le informazioni relative all’ufficio:

var ws = new CodiceUnivocoFatturazioneWebService()

// Authorization Id ricevuto dall'ente.
ws.AuthId = "<auth Id>";
// Codice univoco dell'ufficio che ci interessa
ws.CodiceUfficio = "KN3VNW";

ws.PerformRequest();
if (ws.Ufficio == null) return;

// "Ravenna"
Console.WriteLine(ws.Ufficio.Comune);

Molto semplice. Gli altri WebService (sono sette in tutto) operano secondo lo stesso schema. Ricordo che per l’utilizzo dei Web Services della Pubblica Amministrazione è necessario richiedere una specifica autorizzazione. L’Authorization Id è gratuito ed il rilascio è immediato, ma bisogna compilare un apposito questionario.

Installazione

FatturaElettronicaPA.WebServices è su NuGet quindi tutto quel che serve è eseguire:

PM> Install-Package FatturaElettronicaPA.WebServices

dalla Package Console, oppure usare il comando equivalente in Visual Studio.

La libreria è una portable class library e gira senza modifiche sui seguenti ambienti: .NET Framework 4.0 e superiori; Xamarin.iOS; Xamarin.Android; Windows Phone 8; Windows Store apps (Windows 8); Silverlight 5.0. Enjoy!

If you want to get in touch, I am @nicolaiarocci on Twitter.

Michael has a great lineup ready for the next episodes, so make sure you subscribe to his show. It is also available on iTunes.

If you want to get in touch, I am @nicolaiarocci on Twitter.

So, suppose we set the following validation schema:

schema = {
  'test_field': {
    'dependencies': [
      'a_dict.foo', 
      'a_dict.bar'
    ]
  },
  'a_dict': {
    'type': 'dict',
      'schema': {
        'foo': {'type': 'string'},
        'bar': {'type': 'string'}
      }
  }
}

Then, we can validate a document like this:

>>> v = Validator(schema)
>>> document = {
      'test_field': 'foobar', 
      'a_dict': {'foo': 'foo'}
    }

>>> v.validate(document, schema)
False

>>> v.errors
{'test_field': "field 'a_dict.bar' is required"}

This release will not work with Eve 0.5.2 or less so if you want to use Cerberus 0.8.1 with Eve make sure you upgrade to Eve 0.5.3, released today. By the way, yesterday we hit 2K stargazers and 70 contributors on the Eve repository, quite the milestone!

If you want to get in touch, I am @nicolaiarocci on Twitter.

FatturaElettronicaPA è un nuovo progetto open source che ho rilasciato qualche giorno fa assieme alla mia azienda. Si tratta di una libreria C# che permette di leggere, scrivere e convalidare le Fatture Elettroniche aderenti alle specifiche del sistema di interscambio della Pubblica Amministrazione.

Rilasciata come Portable Class Library, FatturaElettronicaPA gira senza modifiche sui seguenti ambienti:

• .NET Framework 4.0 e superiori,
• Xamarin.iOS
• Xamarin.Android
• Windows Phone 8
• Windows Store apps (Windows 8)
• Silverlight 5.0

Come usare la Fattura Elettronica PA

Usarla è molto semplice. Prima creiamo una istanza di FatturaElettronica:

// instanzia una nuova fattura elettronica
FatturaElettronica fattura = new FatturaElettronica();

Quindi leggiamo da un file standard SDI. E’ sufficiente passare un XmlReader attivo al metodo FatturaElettronica.ReadXml():

// lettura da file XML compatibile con formato SDI1.1
var s = new XmlReaderSettings {IgnoreWhitespace = true};
var r = XmlReader.Create("IT01234567890_11111.xml", s);
fattura.ReadXml(r);

La fattura si aggiorna cambiando i valori delle sue proprietà. Qui aggiorniamo il regime fiscale del mittente. Basterebbe una sola riga di codice; usiamo tre linee per una migliore leggibilità:

// modifica valore
var header = fattura.FatturaElettronicaHeader
var prestatore = header.CedentePrestatore
prestatore.DatiAnagrafici.RegimeFiscale = "RF11";

Convalidare una fattura è un gioco da ragazzi. La proprietà Error conterrà tutti gli errori eventualmente riscontrati.

// convalida documento
if (!fattura.IsValid) {
    Debug.WriteLine(fattura.Error);
}

Stampiano la fattura come flusso JSON:

// serializzazione JSON
var json = fattura.ToJson(JsonOptions.Indented);
Debug.WriteLine(json);

Infine, salvarla su file standard SDI è solo questione di aprire un file con XmlWriter e passarlo al metodo WriteXml:

// serializzazione XML secondo lo standard SDI 1.1
var s = new XmlWriterSettings { Indent = true };

XmlWriter w;
var fileName = "IT01234567890_11111.xml"
using (w = XmlWriter.Create(fileName, s)) {
    fattura.WriteXml(w);
}

Installazione

FatturaElettronicaPA è un package NuGet. Per installarlo è sufficiente usare la Package Console manualmente:

PM> Install-Package FatturaElettronicaPA

oppure usare la interfaccia di Visual Studio.

Progetti satellite

FatturaElettronica deriva a sua volta da BusinessObjects, una classe che implementa la (de)serializzazione e la convalida base.

FatturaElettronica.Forms è invece una libreria WinForms che provvede una UI per l’editing e la segnalazione degli errori di convalida. Al momento supporta l’intestazione (header) e viene già usato in produzione nel nostro software gestionale:

In futuro sarebbe utile aggiungere supporto per la visualizzazione e convalida del corpo fattura (Body).

FatturaElettronica.WebServices consente di interrogare i diversi Web Service della Pubblica Amministrazione dedicati alla fatturazione elettronica. Tutti i progetti relativi alla fatturazione elettronica sono disponibili su GitHub.

Perché la Fattura Elettronica Open Source?

Dallo scorso 6 Giugno 2014 i Ministeri, le Agenzie fiscali, le scuole e gli enti nazionali di previdenza non accettano più fatture emesse o trasmesse in forma cartacea. A partire dal 31 marzo 2015 la stessa disposizione è estesa agli altri Enti a carattere Nazionale ed a tutte le amministrazioni locali.

L’adozione delle fatture elettroniche è in pieno svolgimento e non crediamo di sbagliarci immaginando un futuro non troppo remoto in cui questo formato verrà adottato (per imposizione, come ci pare probabile, o per comodità) anche dal settore privato, diventando di fatto lo standard di riferimento.

Noi ci siamo trovati a dover implementare il supporto per la fatturazione elettronica per gli utenti di Amica 10, il nostro software gestionale. Abbiamo pensato che questa fosse una buona occasione per rendere libero il nostro lavoro così che chiunque possa utilizzarlo per mettersi rapidamente al passo e magari decidere di dare una mano in uno dei tanti modi possibili: segnalando problemi, contribuendo direttamente al progetto, o semplicemente parlandone in giro.

Il software è migliore quando è condiviso.

If you want to get in touch, I am @nicolaiarocci on Twitter.

So what is the Resource Owner Password Credentials Grant pattern? According to the official RFC:

The resource owner password credentials (i.e., username and password) can be used directly as an authorization grant to obtain an access token. The credentials should only be used when there is a high degree of trust between the resource owner and the client (e.g., the client is part of the device operating system or a highly privileged application).

A typical use case would be when the remote API maintainer controls the client application. Say that you have a REST API being consumed by your own iOS, Android, WinPhone, desktop or web applications. Users register to your service by creating their accounts. Then, they consume the service using your applications.

Even though this grant type requires direct client access to the resource owner credentials, the resource owner credentials are used for a single request and are exchanged for an access token. This grant type can eliminate the need for the client to store the resource owner credentials for future use, by exchanging the credentials with a long-lived access token or refresh token.

So let’s get back at the proprietary client scenario. The user has just installed the application on his/her device. On first run he/she is asked to provide his/her username and password. These are sent to the OAuth2 server through a SSL/TLS encrypted channel. If the user is registered for the service and the client id, which has also been sent along with the user credentials, is recognised, then the server sends back a valid access token. Otherwise responds with a 401 Unhautorized.

From now on the application will only be using the access token for all requests until, eventually, the token expires. If that happens, the cycle repeats. Please note that in this scenario the client does not need to (and probably should not) store the username and/or password on the local cache. The User Credentials pattern usually relies on long lived tokens so asking again for username and password is not a big deal (you could also opt for permanent, revokable tokens.)

Flask-Sentinel provides two endpoints: one for token creation which defaults to /oauth/token and is consumed by clients, and another for users and clients management, accessible at /oauth/management:

Note that the password is hashed and salted on the server, so no plain password is stored on either sides of the channel.

Only existing users and recognised clients will be provided an access token. A typical token request would be as follows:

$ curl -k -X POST -d \
  "client_id=9qFbZD4udTzFVYo0u5UzkZX9iuzbdcJDRAquTfRk&
   grant_type=password&
   username=jonas&
   password=pass" \
   <api_url>/oauth/token

And the response would be like so:

{
    "access_token": "NYODXSR8KalTPnWUib47t5E8Pi8mo4", 
    "token_type": "Bearer", 
    "refresh_token": "s6L6OPL2bnKSRSbgQM3g0wbFkJB4ML", 
    "scope": ""
}

The client can now use the access token to access protected API endpoints:

$ curl -k -H \
  "Authorization:Bearer NYODXSR8KalTPnWUib47t5E8Pi8mo4" \
  <api_url>/endpoint

200 OK

There are a number of configuration options of course, for example you can change the url of token and management endpoints, set token expiration, setup database connection, stuff like that. Redis is used to store active access tokens, allows for optimal performance.

While you can use Flask-Sentinel to extend an existing API, you might want to instance it as a stand-alone Flask application to optimize for scalability. You would end up with a distributed network of three different (micro)services: the OAuth2 server, the resouces API with protected endpoints as needed, and the Redis instance bridging the two. Check out the project page on GitHub for details.

Of course Flask-Sentinel integrates seamlessly with any Eve powered REST API. Check out the Eve-OAuth2 sample, a fork of the original Eve-Demo project with a couple protected endpoints and a static HTML page, also protected.

The project is very new and lacks a few little things, but I suspect it is already usable even at this stage. Enjoy!

If you want to get in touch, I am @nicolaiarocci on Twitter.

As with all Eve extensions, once installed with

$ pip install eve-sqlalchemy

using Eve-SQLAlchemy is very simple:

from eve import Eve
from eve_sqlalchemy import SQL

app = Eve(data=SQL)
app.run()

On a fresh virtualenv (of course you are using virtualenvs, right?) the install will also setup Eve and all its dependencies for you. For a complete tutorial you can visit the Eve-SQLAlchemy Support Website.

If you have been following the Eve development you probably know that the original plan was to release SQL support within the Eve core, alongside with the native MongoDB layer. In fact, in a long rant on open source and code responsibility I took the chance to outline the path forward.

However, if you check the discussion which spread in the comments below that post you can see how both my friend and fellow MongoDB Master Flavio and the main contributor to the sqlalchemy branch Andrew were suggesting that a plugin system for data layers might be more appropriate. Not coincidentally that was easy to accomplish since the Eve data layer system was designed precisely with that goal in mind, right from the start.

So, to make a long story short, in agreement with Andrew who volountereed for the task, we changed plans. He refactored the sqlalchemy branch into a separate repository… and then the official Eve SQL extension was born. This approach also allows the extension and Eve to develop asynchronously which is ideal for a faster release cycle.

I like this setup so much that, if in time it shows to be as good as I think it will be, I will probably want to experiment with taking the MongoDB layer out of Eve core too. So with Eve 0.6 MongoDB support would still be preinstalled along with core (so nothing changes as first time user experience) but, being a separate package, users could easily switch to a different driver as they need, still keeping their Eve setup as light as possible.

So if you are willing to help with the development of a mature SQL driver please feel free to join Andrew and other contributors. Your help is more than welcome. Allow me thank them all individually, for the work they’ve been doing on the SQL code is absolutely amazing: Andrew Mleczko, Tomasz Jezierski (Tefnet), Bruce Frederiksen, Jacopo Sabbatini and Peter Zinng.

Get Eve-SQLAlchemy v0.1 while it’s hot!

If you want to get in touch, I am @nicolaiarocci on Twitter.

$ curl -I charliehebdo.fr
Date: Mon, 12 Jan 2015 15:56:13 GMT
Content-Type: text/html; charset=iso-8859-1
Content-Length: 221
Connection: keep-alive
Location: http://www.charliehebdo.fr/index.html
Vary: Accept-Encoding
X-Charlie-fr: Je suis toujours Charlie.
X-Charlie-en: I am still Charlie.
X-Charlie-es: Todavia soy Charlie.
X-Charlie-de: Ich bin immer Charlie.
X-Charlie-ro: Inca sunt Charlie.
X-Charlie-cz: Jsem stale Charlie.

I find this to be a great way for us techies to somehow contribute and show support for the ongoing anti-terrorism campaign. So if you feel like doing it here is a quick rundown on how to serve custom headers with your Eve-powered REST API. It is actually a very easy task to accomplish.

Eve provides its own set of callback hooks but since we don’t need fine-grained control (we are good with including the new header with all responses), this time we will leverage Flask’s native callback system instead.

@app.after_request
def after_request(response):
    response.headers.add('X-Charlie', 'Je Suis Charlie.')
    response.headers.add('X-Ahmed', 'Je Suis Ahmed.')
    return response

A simple run script would then look something like:

from eve import Eve
app = Eve()

@app.after_request
def after_request(response):
    response.headers.add('X-Charlie', 'Je Suis Charlie.')
    response.headers.add('X-Ahmed', 'Je Suis Ahmed.')
    return response

if __name__ == '__main__':
    app.run()

All API responses now include the custom headers:

$ curl http://localhost:5000
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 141
Server: Eve/0.5 Werkzeug/0.9.6 Python/2.7.8
Date: Mon, 12 Jan 2015 15:39:36 GMT
X-Charlie: Je Suis Charlie.
X-Ahmed: Je Suis Ahmed.

If you want to see it in action try sending a GET request with curl, Postman or similar tool to the Eve demo instance (source). Remember Eve is a Flask subclass so whatever works with Flask generally works with Eve too.

If you want to get in touch, I am @nicolaiarocci on Twitter.

Nuts & Bolts

Let’s say that we have a simple class:

>>> class Person(object):
...     pass

We create a Person instance and add a few properties and values:

>>> p = Person()
>>> p.name = "bill"
>>> p.age = 44

Now let’s instance a Cerberus Validator and set up some validation rules for it:

>>> from Cerberus import Validator
>>> schema = {
...     'name': {'type': 'string'},
...     'age': {'type': 'integer', 'min': 0}
... }
>>> v = Validator(schema)

As you probably know already, all Python user objects have a __dict__ magic method which exposes class and instance attributes as a dictionary. This means that we can also query our class like this:

>>> p.__dict__
{'name': 'bill', 'age': 44}

>>> p.__dict__['age']
44

You see where we are going with this: we can exploit the __dict__ method in order to let Cerberus perform validation on our object:

>>> v.validate(p.__dict__)
True

Validation succeeds because current attribute values do not break any rule. However, if we break the rules we do get what we deserve:

>>> p.age = -1
>>> v.validate(p.__dict__)
False

>>> v.errors
{'age': 'min value is 0'}

This works, but is somewhat clumsy. We can do better.

A Custom Object Validator

How about letting the Validator do the work for us? We could subclass the standard Validator and extend it to natively support object validation.

>>> class ObjectValidator(Validator):
...     def validate_object(self, obj):
...         return self.validate(obj.__dict__)
...

>>> v = ObjectValidator(schema)
>>> v.validate_object(p)
False

>>> v.errors
{'age': 'min value is 0'}

>>> p.age = 44
>>> v.validate_object(p)
True

Much better. But what happens if we add a new property and then validate the object?

>>> p.lastname = 'white'
>>> v.validate_object(p)
False

>>> v.errors
{'lastname': 'unknown field'}

Validation fails because by default unknown fields are not allowed. This might not be the desired behaviour. If this is the case, we simply need to update the helper method in our custom validator class:

>>> class ObjectValidator(Validator):
...     def validate_object(self, obj):
...         self.allow_unknown = True
...         return self.validate(obj.__dict__)

>>> v.validate_object(p)
True

By setting allow_unknown to True we let unknown fields be ignored by validation. If we are not concerned by state changes between calls we might conveniently choose to move the setting of allow_unknown to the __init__ method so it gets executed only once.

Looks good so far. We can validate simple objects. But what about complex ones like those exposing other objects as attributes? This is going to require some more tinkering.

Validating Complex Objects

It would be super handy if we could add support for an object data type and then provide a validation schema for it, like we already do with the dict and list types. A revised validation schema would then look like this:

>>> schema = {
...     'name': {'type': 'string'},
...     'age': {'type': 'integer', 'min': 0},
...     'address': {
...         'type': 'object',
            'schema': {
...             'street': {'type': 'string'},
...             'zip': {'type': 'integer'}
...         }
...     }
... }

We could then validate it like so:

>>> class Address
...     pass

>>> addr = Address()
>>> addr.street = 'Lexington'
>>> addr.zip = 50238
>>> p.address = addr

>>> v.validate_object(p)
True

>>> p.address.zip = 'not a number'
>>> v.validate_object(p)
False

>>> v.errors
{'address': {'zip': 'must be of integer type'}}

It turns out this is also very achievable. We can leverage Cerberus data type extensibility model to add support for the object type. Then it is just a matter of handling the new type when validating the schema rule. I’m not going into details here but you can check Validating complex objects with Cerberus, a trivial implementation I posted as a GitHub gist.

Closing note

You might be wondering why don’t I add object validation to Cerberus core. Actually, I don’t rule out this possibility but see I like to keep tools as simple, targeted and focused as possible. Besides, there are other object validation tools out there, so adding a new flavour does not seem very useful to me (but let me know if you feel otherwise.) Though as we have seen, if you want to validate user objects with Cerberus, you can do that easily enough.

If you want to get in touch, I am @nicolaiarocci on Twitter.

I’ve started to associate .Net “classic” with seemingly constant aggravations like strong naming conflicts, csproj file merge hell, slow compilation, slow nuget restores, and how absurdly heavyweight and bloated that Visual Studio.Net has become over the years.

It is me. No it’s actually Jeremy but really it’s me. I also share his concerns on the future OSS .NET community him:

So much of .Net is open source now and they even take contributions. Awesome, great, but my very first reaction was that it doesn’t matter much because the .Net community as a whole isn’t as participatory as other communities and that would have to change before ASP.Net vNext being OSS matters. It’ll be interesting to me to see if that changes over time.

I’m very involved with the Python language and its community. I released open source projects for both platforms and frankly I’ve been shocked by the difference in culture between the two communities. I am really hoping that, in due time, .NET going open source will also cause its community to evolve as a whole.

And what about coding on a Mac (or Linux for the matter)? He goes on with:

After a couple years now of using a Mac, I’d really prefer to stay on that side of things and hopefully give my Windows VM much more time off. Mac OS being a first class citizen for the new .Net and the progress on the OmniSharp tools for Sublime or MacVim is going to make the new ASP.Net vNext runtime a much easier sell in my shop.

I’ve been working on a Mac for years, confining Windows on a VM, doing Python with Vim as much as possible. My God I love Vim. My Visual Studio runs VsVim (which is open source by the way). Even my Xamarin Studio on OSX runs in vi mode (which sucks unfortunately). I would never go back to a Windows machine but that does not mean that I don’ want to use C# or F#. Even these days most of my coding is C# in XS/OSX or Vim with OmniSharp, a project I’ve been experimenting with since when the plugin for Vim was released. So native .NET on OSX and Unix? Yes please.

I am in the process of writing a C# iOS application. The data layer is SQLite encapsulated in a Portable Class so we can use it on both Windows and iOS. The HTTP/REST client is also portable, open source and consumed on both platforms. And now even the mobile UI is C# and portable between Android, iOS and Windows Phone thanks to Xamarin.Forms. If you ask me, the future looks bright.

You should read Jeremy post on his site.

If you want to get in touch, I am @nicolaiarocci on Twitter.

Written and maintained by the same author of the Eve Framework itself, Eve.NET is delivered as a portable library (PCL) and runs seamlessly on .NET4, Mono, Xamarin.iOS, Xamarin.Android, Windows Phone 8 and Windows 8. We use Eve.NET internally to power our iOS, Web and Windows applications.

And now please forgive me while I take you on a quick motivational, strongly opinionated, probably boring and overzealous detour

Python and C# Motherfucker, Do You Speak It? *

If you don’t then well, you should consider doing just that. Especially so these days, with C# and the whole .NET platform going open source and cross platform. Actually, thanks to technologies like Mono and Xamarin (also based on Mono) we have been able to run C# code on all major platforms for a while: iOS, Android, OSX, Linux, Windows, Windows Phone, you-name-it. And what’s even better, on mobile platforms C# is compiled to native so performance is a non-issue.

What makes C# a perfect match for a REST API is precisely that: it’s ubiquity. You can have a portable client library like Eve.NET which runs seamlessly (and untouched) on all these mobile desktop and server platforms.

If you already have a Web Service running on Eve and are now looking at the client side of things then well, you should consider C# and Eve.NET because you know, you can’t have a native iOS app written in Python anyway. On the other hand if you are a C#/.NET shop consider this: you can have a powerful Web Service up and running in minutes (even if you don’t grok Python yet – trust me on that) and a complete out-of-the-box, cross platform client library ready to go with it.

A few years ago I gave a talk about leaving my Comfort Zone (**) and getting out of my .NET nest. That opened the path to Python, MongoDB, Node and so many other technologies and best practices and, what’s even more relevant, most of what I learned down that path I ended up using in my .NET projects in the long run. But the point I’m trying to make is don’t be afraid of change, it can only improve your skills making you a better all-around professional programmer.

Never mind the naysayers. Polyglot is the way.

(*) I’m paraphrasing Zed A. Shaw’s Programming, Motherfucker. You should get a T-Shirt by the way. They are so cool.

(**) Since then there have been plenty of talks on the same subject. Mine was an 5 minutes ignite talk and was in Italian, so you probably don’t care (it’s on my Talks page anyway).

Back to business now.

Usage

Initialization is as simple as instantiating a new client and providing it with the web service entry point.

// Initialize and set API address.
var client = new EveClient();
client.BaseAddress = new Uri("http://api.com");

// Set target resource for subsequent requests.
client.ResourceName = "companies";

Getting a list of objects is pretty straightforward:

// List<T>
companies = await client.GetAsync<Company>();

// Objects changed since DateTime.
var ifModifiedSince = DateTime.Now.AddDays(-1);
companies = await 
  client.GetAsync<Company>(ifModifiedSince);

// Refresh an object
company = await client.GetAsync<Company>(company);

// Raw, conditional GET request
var companyId = "507c7f79bcf86cd7994f6c0e";
var eTag = "7776cdb01f44354af8bfa4db0c56eebcb1378975";

company = await 
  client.GetAsync<Company>("companies", companyId, eTag);

Other CRUD operations are easy too:

// Create (POST)
company = await 
  client.PostAsync<Company>(
    new Company { Name = "MyCompany" }
  );

// Update (PUT)
company.Name = "YourCompany";
var result = await client.PutAsync<Company>(company);

// Delete (DELETE)
var result = await client.DeleteAsync(company);

As you can see all methods are Async and return full object instances parsing JSON in and out on for you. If you need more control you can query the HttpResponse property to inspect the original JSON, response headers, status code, etc.

Behind the scenes data integrity and concurrency control are transparently handled so for example PutAsync performs a If-Match check and same happens with DeleteAsync. On PostAsync new objects are returned with fresh meta-fields such as ETag, DateCreated, DateUpdated and UniqueId. Mapping object properties to JSON fields and Eve metafields is just a matter of setting the JSonPropertyAttribute and RemoteAttribute:

public abstract class BaseClass
{
  [JsonProperty("_id")]
  [Remote(Meta.DocumentId)]
  public string UniqueId { get; set; }

  [JsonProperty("_etag")]
  [Remote(Meta.ETag)]
  public string ETag { get; set; }

  [JsonProperty("_updated")]
  [Remote(Meta.LastUpdated)]
  public DateTime Updated { get; set; }

  [JsonProperty("_created")]
  [Remote(Meta.DateCreated)]
  public DateTime Created { get; set; }   
}

public class Company : BaseClass
{
  [JsonProperty("n")]
  public string Name { get; set; }

  [JsonProperty("p")]
  public string Password { get; set; }
}

For a complete list of usage examples see the README

Current Status and License

Eve.NET is a Nicola Iarocci and Gestionali Amica open source project distributed under the BSD license. It is a work in progress but it’s pretty stable already. It is available on NuGet as a pre-release package. The test suite can be run against a local Eve instance or, if you don’t grok Python yet, you can use a free test instance which is available online, see the README for details.

Did you read this far? Well thank you! And please, consider showing your appreciation by starring the project on GitHub. It feels so lonely out there.

If you want to get in touch, I’m @nicolaiarocci on Twitter.

We rule the world.

We don’t quite understand this yet. More importantly, the world doesn’t quite understand it yet. Our civilization doesn’t quite realize how dependent it has become on software — on us.

He goes as far as suggesting a programmer’s code of conduct of sorts. Food for thought I guess, although I suspect we’re too much of a wild and scattered bunch for something like that to really stick.

Nonetheless, he raises a very good point about the predominance of software in our society and the risk that soon or later someone will wake up and attempt to impose some sort of regulation on the profession.

Read it all at the Clean Coder Blog.

At some point during the debate, I argued that when a maintainer merges a pull request, he (or she) implicitly agrees on being responsible for that code. That seemed to strike some surprise into most attendees.

Yes, in theory any contributor is just a ping away so in case trouble arises one can always reach him, or her. Unfortunately this is not always the case. While some contributors will fully embrace your project and keep helping after their initial contribution, truth is that a good number of them will just move on, never to be seen again.

There’s nothing wrong with that. Not everyone has spare time to devote to your project, which is perfectly fine. It is natural for most people to contribute what they need to a project and then go on their way. Actually, one could argue that most projects grow and prosper precisely thanks to this kind of contributions.

However this attitude can become an incumbent when big chunks of code get merged, usually as new (big) features. Good practices advice against merging huge pull requests. In fact they are rare and when they do come, it is a good idea to ask for them to be split into smaller ones. But no matter the format, a huge contribution is likely to hit a project one day or another. It might even come from more than one person: a disconnected and distributed team of contributors who have been patiently tinkering on a side branch or a fork for example. When this happens, and provided that the contribution is worth merging, the maintainer should then ask him/herself the obvious question: am I willing to deal with the consequences of this merge?

In fact this is the exact scenario I’m dealing with right now. The Eve project has always been a MongoDB shop. Since its inception however people have been asking if (when) SQL support was going to be added. I think we were in Alpha when someone started contributing SQL code. Over time I ended up devoting a specific branch to this feature. Several people have been hacking at it since then, and what a splendid job they did! To say that it was a huge commitment is an understatement but, in time, they managed to deliver. So now we have this awesome sqlalchemy branch which is feature complete and ready to be merged ahead of the new Eve release. We’re talking 4K+ lines of code and 44 files changed. Code quality is not under discussion. I know that several companies and individuals have been using that branch in production with good success, even when it still was at its early stages.

This is very exciting as adding SQL support has a good chance to greatly improve the audience of the project. At the same time however, I’m a little bit nervous if not scared, and I have been for a while. Am I ready to deal with the consequences of this supermerge? Inevitably SQLAlchemy tickets will be opened and Stack Overflow questions will be asked. SQL-related pull requests will come in and mailing list posts will flock. To be honest I don’t think I can handle that, let alone allocate more of my free time to the project. Also, I’m not very confident with SQLAlchemy itself so I would not be the best person deal with that code anyway. In the recent past while discussing SQLAlchemy support on the mailing list, I have been very clear about my concerns, so much that I probably scared a few people away. What worries me the most, I suspect, is the risk of new code becoming stale one day or another. In time that would probably impact the reputation of the whole project.

To think about it, we already had something similar happen in the past, although for a smaller feature. The Document Versioning pull request, contributed by the amazing Josh Villbrandt, had been daunting me with similar thoughts. New code was going to be be quite intrusive, adding a good deal of complexity to an otherwise relatively simple codebase. Everything went amazingly well though. Josh is still an active contributor. He helps with improving his own feature and, even more importantly, other contributors are now helping with Document Versioning as we speak. Overall, the Eve project as a whole as been enjoying a growing number of skilled contributors and adopters. It’s been a joy to see people commenting on open tickets, offer support on the mailing list and even on Stack Overflow. So that should be encouraging.

So here I sit, with 4K LOCs ready to be merged. What do I do with them? I considered a few options. One is leaving the SQL feature in a separate branch. Another is to ask the team to refactor the whole thing into an external extension (we have a few already). By doing any of these Eve-core would remain MongoDB only and I could keep managing it on my own. But then again, none of these options would add native SQL support to Eve. Also, an extension or a branch would run even a greater danger of becoming stale.

At some point I guess even mildly successful projects like Eve have to decide wether they want to outgrow their author. I strongly believe that growing and trusting communities is all that open source is about. You release your work out there and, even at that early stage, you are already entrusting people. You trust that they will take notice and then that they will validate your project (or not). Eventually, someone will review your code, adopt it and, in time, contribute. The project then grows up to a point where its community becomes so predominant that you, as the author and maintainer, just have to let some control go.

So yes, SQL support is coming to Eve, and as a native feature. I trust that the contributors to the SQLAlchemy backend will stay around and, if they won’t, that someone else will stand up and take the torch. I am also confident that the community as a whole will adopt the feature, make it grow and well… we’ll see what happens next.

If you want to get in touch, I’m @nicolaiarocci on Twitter.

What is the OpLog?

The OpLog is a special resource that keeps a record of operations that modify the data stored by the API. Every POST, PATCH, PUT and DELETE operation can eventually be recorded by the oplog.

At its core the oplog is simply a server log, something that’s always been on the Eve roadmap. What makes it a little bit different is its ability to be exposed as a read-only API endpoint. This would in turn allow clients to query it as they would with any other standard endpoint.

Every oplog entry contains few important informations about the document

involved with the edit operation:

• URL of the endpoint hit by the operation.
• Kind of operation performed.
• Unique ID of the document.
• Date when the document was updated.
• Date when the document as created.
• User token, if User Restricted Resource Access is enabled for the endpoint

Like any other API-maintained documents, oplog entries also contain:

• Unique ID
• ETag
• HATEOAS meta fields, if enabled.

A typical oplog entry would look something like this:

{
    "o": "DELETE", 
    "r": "people", 
    "i": "542d118938345b614ea75b3c",
    "_updated": "Fri, 03 Oct 2014 08:16:52 GMT", 
    "_created": "Fri, 03 Oct 2014 08:16:52 GMT",
    "_id": "542e5b7438345b6dadf95ba5", 
    "_etag": "e17218fbca41cb0ee6a5a5933fb9ee4f4ca7e5d6"
    "_links": {...},
}

To save a little storing space field names have been shortened when possible (what can I say, I’m a MongoDB guy): o stands for operation, r stands for resource, i stands for unique ID and c stands for changes. Other keys are defined by the configuration settings, and their default names are shown here.

How is the oplog operated?

Three new settings keywords are available:

• OPLOG

  Sets the oplog name and defaults to oplog. This is the name of the collection on the database and also the default url for the oplog endpoint.

• OPLOG_METHODS

  A list of HTTP methods for which oplog entries are to be recorded. Defaults to ['DELETE'].

• OPLOG_ENDPOINT

  Set it to True if an oplog endpoint should be made available by the API. Defaults to False.

• OPLOG_AUDIT

  If enabled, IP addresses and changes introduced with PATCH and PUT methods are also logged. Defaults to True.

So by default the oplog is stored on a conveniently named oplog collection, it only stores informations about deleted documents.

Since the eventual oplog endpoint is a standard API endpoint, if it is enabled the API maintainer can also fiddle with the endpoint settings as he/she would do with any other Eve endpoint. This allows for setting custom authentication (you probably want this resource to be only accessible for administrative purposes), changing the url, etc. Just add an oplog entry to the API domain, like so:

'oplog': {
    'url': 'log',
    'auth': my_custom_auth_class,
    'datasource': {'source': 'myapilog'}
}

Note that while you can change most settings, the endpoint will always be read-only, so setting either resource_methods or item_methods to something else than ['GET'] will serve no purpose. Also, unless you need to do so, adding an oplog entry to the API domain is not required as it will be added automatically for you.

Why the OpLog?

Clients have always been able to retrieve changes by simply querying an endpoint with a If-Modified-Since request. So why do we need an operations log? Of course because server-side logging is cool, and so is auditing, but it’s not only about that.

Single entry point for all API updates

From the client perspective and for most use cases logging inserted, edited and replaced documents is probably a waste of both space and time, and this is the main reason why only DELETE operations are logged by default. However, I believe there are scenarios where remote access to a full activity log can be useful.

Imagine an API which is accessed by multiple apps (say phone, tablet, web and desktop applications) and all of them need to stay in sync with each other and the server. Instead of hitting every single endpoint with a IMS request they could just access the oplog. That’s a single request vs several, and since the oplog itself is a standard API endpoint, they could also perform IMS requests against it for optimal gains:

Server, please send me all the changes occurred to the API since my last access. Sincerely, Your Client.

Again this is not always the best approach a client could take. Sometimes it is probably better to only query for changes when they are really needed, but it seems cool to have both approaches available (and remember, the oplog endpoint is disabled by default).

Fixing 304s

And then there are deleted documents which are a completely different beast. With no oplog we would have no way to tell if and when any document has been deleted, let alone inform clients about that. Actually, there is an open ticket precisely about this, and it’s been sitting there for a while.

When a If-Modified-Since request is received, the API is expected to respond with a 304 Not Modified status if no changes occurred, so that clients can conveniently fallback to cached data. Up to version 0.4 (the official release at the time of this writing) Eve has been doing exactly that, with one caveat: missing documents were being ignored as, in the contest of the IMS request, there was no way to know about them.

The operations log will allow Eve powered APIs to take deleted documents into account, returning perfectly proper 304 codes as needed. The impact on performance should be minimal as we will only query the oplog when and if no changes have been detected on the target collection.

This solves only one half of the problem however. What happens when a IMS request comes in and deleted documents are found in the backlog? How do we report them back to the client? Three options come to mind which would address this scenario:

1. Respond with a 200 OK and a the usual “changes since IMS date” payload, which might happen to be empty if only deletions occurred in the time window. The client can then go and query the oplog endpoint with the same IMS date, finally getting the list of deleted documents IDs.

2. Include deleted documents IDs in the standard payload (within the _items list), maybe with a deleted status tag. This status tag is something new though, and for consistency we should probably add it to other objects in the payload.

3. Add support for a new _deleted meta field in resource payloads. When deleted documents are spotted in the backlog the response payload will include them in their own list. Something like this:

First option is so bad I should probably not be listing it at all. It would take two roundtrips to get the whole update down. Also, it would kind of force API maintainers to open the oplog endpoint to their clients.

I’m not convinced #2 would be a good idea either, as objects in the items list would not be homogeneous anymore and we would have to add support for a new meta field anyway (the status tag).

Option #3 on the other hand looks quite good to me. It does not require multiple requests to handle the case of deleted documents on IMS requests, and it is still easy and clean for clients to process. I am going to go with #3 unless feedback is negative and for good reasons, so let your opinion be heard.

Closing concerns

I am slightly concerned about the performance impact, not so much on IMS requests but rather on write operations, especially when a complete, all-operations log is being recorded.

In MongoDB world OpLog is probably an ideal candidate for a capped collection. I’m not entirely convinced about that though, as by its nature a capped collection is bound to lose data over time, which again might lead to inaccurate 304 handling.

I am not implementing the OpLog at the data layer level however. It is a business layer feature to let other engines take advantage of it. Nothing prevents the MongoDB admin from setting the oplog as a capped collection anyway. Also, keep in mind that like all other resources maintained by the API, indexes are not handled by Eve itself so you will have to do your homework in that field too.

So here you have it. I’m currently done on both configuration and logging parts and will be working on 304 handling and response payloads in the coming days so that all of this can be included with next version 0.5. Be warned that at the moment the develop branch has no support for IMS requests on resource endpoints. It’s been disabled to avoid providing clients with inaccurate responses (see the ticket above).

If you have any comment or feedback to provide, please let me know in the comments below. I’d really appreciate that.

PS. In case you are wondering yes, the Eve OpLog is heavily inspired by the awesome MongoDB OpLog.

An OrderedDict is a dict that remembers the order that keys were first inserted. If a new entry overwrites an existing entry, the original insertion position is left unchanged. Deleting an entry and reinserting it will move it to the end.

Problem is, this stuff is only available in the standard library since Python 2.7 while my project also needs to support Python 2.6. Fortunately there’s a back-port available and it is only a pip install away:

# make OrderedDict available on Python 2.6-2.4
$ pip install ordereddict

ordereddict is based on the awesome recipe by Raymond Hettinger, works with Python 2.4-2.6 and, most importantly, is a drop-in replacement for OrderedDict.

However if you want your code to run seamlessly on all Pythons there’s still some work to be done. First of all you want to make sure that the appropriate OrderedDict is imported, either the standard library version (for Python 2.7 and above) or the back-port release.

This is easily accomplished, and in a very pythonic way:

try:
    # try with the standard library
    from collections import OrderedDict
except ImportError:
    # fallback to Python 2.6-2.4 back-port
    from ordereddict import OrderedDict

Fixing setup.py

If you are shipping your code as a package then you also want to make sure that setup.py properly handles the different Python versions. Since setup.py itself is nothing but standard Python module, we can make it more dynamic by applying the same technique above.

#!/usr/bin/env python
from setuptools import setup, find_packages

# your standard required modules
install_requires = [
    'simplejson',
    'cerberus',
    'events',
    ...
]

try:
    from collections import OrderedDict
except ImportError:
    # add backport to list of required modules
    install_requires.append('ordereddict')

setup(
    name='appname',
    version='0.1',
    packages=find_packages(),
    ...
    # no matter which Python, we're now good to go
    install_requires = install_requires,
    ...
)

Handling requirements.txt

When it comes to pip’s requirements.txt, what I think works best is to simply add a diff file which targets old Python versions like so:

# py26-requirements.txt
# install from 'canonical' requirements.txt first (DRY)
-r requirements.txt
# add specific Python 2.6 dependencies
ordereddict

A developer using Python 2.6 would then go with

$ pip install -r py26-requirements.txt

Whereas someone on a recent Python would simply run

$ pip install -r requirements.txt

Since py26-requirements.txt explicitly lists Python 2.6 dependencies only and then relies on requirements.txt, most likely you will only need to update the main requirements when/if new dependencies are needed.

You can check out the commit where Python 2.6 support for OrderDict has been introduced.

If you want to get in touch, I’m @nicolaiarocci on Twitter.

Portable Class Libraries and .NET Framework 4

The first thing you should know is that while the .NET Framework 4 does support PCLs, in fact it won’t run them without a patch. For whatever reason, Microsoft decided that PCL compatibility wasn’t a worth a 4.0.4 update. That leaves us with the need to not only make sure that target machines are running the up-to-date .NET4 release (v4.0.3) but also that they’ve been updated with KB2468871.

You might be wondering why this is an issue in the first place. We could simply install the .NET Framework 4.5 which is backward compatible with the .NET4 and includes the afore mentioned KB2468871. Even better, we could just target the .NET 4.5 on our PCL. Problem is that besides iOS, Android, WinPhone and Silverlight we also want our libraries to run seamlessly on as many Windows editions as possible, Windows XP included. Here is the catch: .NET4 is the last framework version to run on Windows XP. And yes, we got the memo, Microsoft officially abandoned Windows XP a while ago so why bother? Well it turns out that millions of users are still running XP, especially so in the enterprise and SMB. These PCL are targeting exactly that, precisely the accounting software segment, and believe me there’s a huge number of users happily invoicing and accounting on their old-fart-but-still-splendidly-doing-its-job-for-cheap boxes. Oh and the .NET Framework 3.5 is not an option as it doesn’t support Portable Classes at all.

All things considered, it’s still good news. We can build PCL which run everywhere, Windows XP included. We only need to make sure that both the .NET Framework 4 and the KB2468871 are installed on target machines. Easy enough, right?

The strange story about KB2468871 InstallShield Prerequisite

We rely on InstallShield for building our distributions, so I was delighted to find that it comes with a KB2468871 Setup Prerequisite out of the box. All we had to do was add the prerequisite to our setup and we would be done. In fact, our first test was encouraging. We ran the setup on a pristine Windows XP. It installed the .NET Framework 4, then the KB patch and then, finally, our own application which included the PCL libraries. Everything was running smoothly. We then moved on to test the same identical build on a fresh Windows 7 machine. Again, it installed the .NET4 just fine… and then it crashed. Actually, the setup itself did not crash. It was the KB2468871 which was crashing while the main setup itself was left idle, waiting for the KB install to complete. So, what was going on there?

CPU Architecture Does Matter

To make a long story short, after a lot of investigation and an embarrassingly high number of tests we found that our setup was only crashing on 64bit editions of Windows. It turned out that the issue was with the InstallShield Prerequisite itself. It was broken. In a bad way.

The KB2468871 comes in three flavors:

• NDP40-KB2468871-v2-x86.exe
• NDP40-KB2468871-v2-IA64.exe
• NDP40-KB2468871-v2-x64.exe

Three executables, each one targeting a different architecture. Upon inspection of the stock prerequisite however, we discovered that it was launching the x86 executable no matter what the target edition of Windows was. That explained the crashes on x64 systems.

The solution was to create a new custom prerequisite which would download and launch the x64 KB edition on 64bit systems. We then had to update the stock prerequisite too, so that it would only run on x86 systems. So we now had two specialized KB2468871 prerequisites. One for 32 and another for 64 bit systems. They would be launched alternatively depending on the target system. We proceeded to add them both to our InstallShield project and rebuild it. Then we went and tested it against freshly installed Windows. It installed the .NET Framework 4, then totally skipped the KB (like the prerequisite didn’t even exist) and finally proceeded to install both PCL and main application – which of course would crash on execution as there was no KB on the system.

Beaten, but not ready to admit defeat yet, we went back to the drawing board.

Execution Order Does Matter. Or Not.

Our custom launch conditions for both our KB prerequisites were there, and they looked good. Then there was this other conditional triplet. It was validating two registry keys and then making sure that mscorlib.dll existed in .NET4 folder. So, the idea was that the KB installation should only be executed if the .NET4 was on the target system. That sounded perfectly reasonable. As we could configure the order in which prerequisites were executed, we just had to make sure that the .NET4 prerequisite was assigned a higher priority, so it would run before the KB prerequisites themselves. The prerequisites order was fixed, a new setup was built and… nothing changed. KB were still not being installed.

Prerequistes order did not seem to matter. In fact, if we removed that check-if-net4-is-there conditional triplet the KB would install. However that was not an acceptable solution because then the KB would always be installed, causing a reinstall (and a waste of time and resources) on most systems.

Then I had my epiphany. Maybe launch conditions were being evaluated all together at boot time, for all prerequisites, before they were installed and regardless of their execution order? Non-sense you might think (I did). Why allow me to set an execution order in the first place, if launch conditions for each item are not going to be evaluated in that order? Luckily, validating this theory was going to be quick and easy. We just had to reboot the system after the faulty installation was completed, then run the setup again. And guess what? On second run, after the reboot, the KB installation would be executed without a glitch. Bingo. Since the .NET4 had been installed on the previous run, now registry keys were there and the mscorlib.dll was in the right place, so the KB launch conditions were finally met.

We ended up replacing that bogus conditional triplet completely and changing the validation logic. Instead of checking if the .NET4 was installed (on pristine XP and Windows 7 systems, which don’t have the .NET Framework 4 preinstalled, it just could not be there yet), we were now simply checking if KB itself was installed. After all it just needs to be there, no matter the Windows or framework version (on .NET 4.5+ the KB will be installed by default).

So now, armed with our brand new custom KB2468871-x64 prerequisite and a totally re-imaginated set of launch conditions we were finally able to build a setup that would deliver a fully functional Portable Class Library which would run on all possible Windows: XP, Windows 7, Windows 8… independently of the CPU architecture. Victory!

If you read this far you probably noticed that I didn’t include instructions on how to apply these changes to the stock prerequisite, let alone create a new one. You can find those instructions on the InstallShield website, or you can simply use our modified prerequisites. Of course we are providing them without any guarantee that they will work for you. They did for us, and that’s it.

Too long; didn’t read

1. Portable Class Libraries won’t run on plain vanilla .NET Framework 4.0 unless KB2468871 is installed;
2. If using InstallShield KB2468871 Setup Prerequiste you’re in for a wild ride;
3. However, and until an official fix is released, you can opt to use our modified prerequisites instead.
4. Get the custom KB2468871 (64x) InstallShield prerequisite.
5. Get the custom KB2468871 (x86) prerequisite.

Conclusion

The stock KB2468871 InstallShield prerequiste has been out for a good while so I’m baffled that to this day I still cannot find any reference about these issues on the internet. Portable Class Libraries are probably still a niche and the fact that most of Macrovision KB resources are hidden behind a wall does not help. Soon or later an official prerequisite update will be released. Until then, feel free to use our mods.

I’ll just add that if we were dealing with an Open Source project, we’d just open a pull request and be done with it.

If you want to get in touch, I’m @nicolaiarocci on Twitter.

My REST APIs for Humans™ talk was given in a fully packed Python DevRoom, which granted a lot of smart questions both in the final QA session and later during the day. Thanks everybody for the great feedback!

Now the project is out in the wild and I’m very excited about it. It’s all italian yes, but do know that CoderDojo is a global movement, and starting a kids coding club in your own town would probably be great idea.

Come meet me next week. I will be giving a short talk about CoderDojo Ravenna and, most importantly, we’ll have a good pizza afterwards. Oh, and we’re looking for mentors to join us.

What we had before was basically a list of human-readable errors. Each item in the list, while perfectly fine for human reading, wasn’t really ideal for algorithmic parsing. Why would you want to parse the errors with an algorithm? A common case would be when your client is using business objects to represent API resources (think a client-side ORM), and would have a hard time binding validation errors to the objects themselves.

So for example, previously we had:

[
    "min value for field age is 10",
    "value of field name must be of string type"
]

With Cerberus 0.5+ we now have:

{ age: min value is 10, name: must be of string type }

Let’s look at more complex structures, like lists. Imagine we have a schema defined like this:

schema = {
    'list_of_values': {
        'type': 'list',
        'items': [{'type': 'string'}, {'type': 'integer'}]
    }
}

And this is the document we want to validate against it:

document = {
    'a_list_of_values': ['a string', 'not an integer']
}

Validation will of course fail and, given the new dictionary format, inspecting the errors property will return the following:

>>> v = Validator(document, schema)
False

>>> v.errors
{1: 'must be of integer type'}

Let’s look at a document that contains a list of dictionaries instead:

document = {
    rows: [
        {'sku': 1, 'price': 100},
        {'sku': 'hello', 'price': '1'}
    ]
}

Validation errors will be reported like this:

{
    rows: {
        0: {
            'sku': 'must be of string type',
            'price': 'must be of integer type'
        },
        1: {
            'price': 'must be of integer type'
        }
    }

}

By contrasts, on top of my memory, any previous Cerberus release would report:

[
    "rows[0]": 'field "sku" in must be of string type',
    "rows[0]": 'field "price" in must be of integer type',
    "rows[1]": 'field "price" in must be of integer type'
]

As you can easily see, the old implementation was forcing the client to properly parse the list in order to retrieve line number, offending field and the actual error. Overall Im fairly confident that this is an important step forward. Checkout the documentation, which has been updated to reflect the changes.

Get Cerberus 0.5 while its hot.

For a very long time I’ve not been able to tell the precise reason why I keep going back to traditional books. It’s not about the reading experience or the sexiness of turning physical pages. Well of course that matters too, as I’ve always been kind of a book fetishist, but since the very beginning of my love-hate relationship with the Kindle I’ve always known there had to be something else, and I couldn’t pin it down.

Then yesterday it finally struck me. I was visiting the awesome Silent Books exhibition with the kids, and there was this Suzy Lee quote pinned on the wall, and I couldn’t stop reading it over and over.

In turning the pages of a book,

a little world opens and closes,

enclosed in a frame.

Story ends, the book closes.

The world closes too.

Then it’s quickly placed on a shelf.

Art can be placed on a shelf.

Shelf-sized art.

Isn’t that beautiful? (*)

So yes, it’s about the shelves. It’s about surrounding myself with those little worlds I’ve been exploring. I suddenly realized that several times every day, while I’m furiously coding or when I’m just walking around the house or heck, even while I’m reading a book, each day my eyes like to indulge on those shelves, the vivid memories of my reading experiences. That’s something the files stored on my precious little Kindle can’t offer me.

That also explains why I only tend to buy what I call ’throw away’ books on the Kindle. These aren’t necessarily bad books (or I wouldn’t buy them in the first place). They are mostly leisure readings, you know, thrillers and the like: something that’s entertaining to read but it isn’t likely to leave me with a long lasting memory, or emotion.

(*) turns out the Border Trilogy, Suzy Lee’s book from which the quote__ is taken, has not been published in english, which is a shame. This is a (probably poor) translation of mine_.

Unfortunately audio is horrible and while all MongoTorino talks were in english, NoSQL Day was an italian-only event. The slide deck is in english however, and is available on both SpeakerDeck and SlideShare.

How did you get involved in open source?

I’ve been an avid developer delivering desktop applications in the .NET/MSSQL closed source ecosystem for so many years that open source wasn’t even on my radar.

Then a few years ago, like everybody else, we found that we needed to get involved with the mobile world. That’s when I thought that it was time to finally to get out of my comfort zone and start looking out of my walled garden. In fact, while historically there always have been little alternative to the Microsoft/.NET/SQL ecosystem for building business Windows applications, now we were about to address a completely different beast.

First step in any mobile strategy is building a proper web infrastructure, like one or more web APIs, remote servers, etc. While .NET was well suited for the task, I knew that there were other valid, robust and mature alternatives out there and that I had to learn more about them before picking any choice.

My involvement with open source, the whole Python language, MongoDB and the NoSQL movement is the direct consequence of that learning process.

Meeting the EMEA MongoDB Masters – Nicola Iarocci

Did you check for a virus on your system?

You must have the wrong version.

It’s a third party application issue.

That code was written by the last guy.

Programming Excuses. We’ve all been there.

Given an arbitrary address this service validates address based off syntax checks (RFC defined grammar), DNS validation, spell checks, and if available, Email ServiceProvider (ESP) specific local-part grammar.

They’re relying on formal grammar and not on regex like the rest of us, which is perhaps the more intriguing aspect of the project. Being Email Service Providers themselves they have good knowledge of most ESPs local-part grammars (the left side of the @ symbol) so when there is a match, they’re validating local-parts too.

At the cost of a slight delay DNS, MX and A record validation adds robustness to the process (didn’t really perceive any slowness during my tests). What really shines however, at least in my eyes, is the included “correct address suggestion service”.

At the moment they are providing a free API  and a mail address validation page. Here’s the catch: consuming the API requires a free Mailgun account. According to their own statement however they are also going to open source the tool and yes, it’s going to be in Python.

Get it on PyPI, go straight to the source code or more likely, visit the project homepage.

If your project really does not need any relational data features, then ORM will work perfectly for you, but then you have a different problem: you’re using the wrong datastore. The overhead of a relational datastore is enormous; this is a large part of why NoSQL data stores are so much faster. If your data is relational, however, that overhead is worth it: your database does not merely store your data, it represents your data and can answer questions about it on the basis of the relations captured, far more efficiently than you could in procedural code.

I don’t really know how this article managed to elude my usually long-reaching radar for such a long time.

Parlerò di MongoDB usato come backend per una REST WEB API. L’evento si svolgerà in serata a Cesena, è gratuito, e ci sono ancora posti disponibili. Se ci siete passate a salutarmi.

Nicola is a champion Pythonista (one of the top 11% most active Python users) who loves pushing code. Nicola is a nine-to-fiver who seems to work best in the mid-afternoon.

Hacking Italia e’ un sito di “social news”, molto simile ad Hacker News, il celebre collettore di news per hacker di YCombinator. A che serve un sito italiano, e in italiano se c’e’ gia’ molto di piu’ e di meglio nel panorama internazionale? A mettere assieme una massa critica di persone “giuste” in Italia.

Vi consiglio di aggiungere HI ai vostri bookmark. Per quanto mi riguarda conto di essere molto attivo.

Il linguaggio C# dispone da sempre di una soluzione elegante al problema della gestione degli eventi: il delegato EventHandler. Events è una mia implementazione Python del EventHandler C#. In pratica si tratta di una classe molto leggera che incapsula il cuore del meccanismo di sottoscrizione e gestione degli eventi, e tenta di farlo in maniera “naturale”, sembrando parte integrante del linguaggio Python.

Come usare Events

Tecnicamente un evento è qualcosa a cui è possibile “attaccare” una o più funzioni di callback. Prima di tutto creiamo una funzione di callback che verrà invocata allo scatenarsi dell’evento a cui siamo interessati:

Poi ‘iscriviamo’ la nostra funzione all’evento:

Notate come l’evento sia al tempo stesso dichiarato e sottoscritto, in un’unico passaggio. Più funzioni possono sottoscrivere lo stesso evento. Quando si scatena un evento tutte le funzioni ad esso collegate vengono invocate in sequenza. Per scatenare l’evento ci basta eseguire una chiamata all’evento stesso:

Un esempio di modello Model-View-Controller

In genere nell’implementazione di uno schema MVC l’istanza della classe Events farà parte di un Modello, come in questo esempio:

Oggetti View e Controller ne sono i tipici  sottoscrittori:

E’ inoltre possibile vincolare il nome degli eventi e fare l’introspezione delle sole due classi che costituiscono Events. La documentazione include gli esempi e le istruzioni per l’installazione; il codice sorgente è a disposizione su GitHub. Buon divertimento!

The Deep Insights of Alan Kay  è un tributo da non perdere a questo vero gigante dell’informatica, tra l’altro impreziosito da una selezione di link ad alcuni dei suoi interventi più importanti, spesso tenuti in occasione del ritiro dei numerosi premi ricevuti in carriera (tra gli altri, l’Alan Turing per il fondamentale contributo alla programmazione orientata agli oggetti).

Il modo migliore di predire il futuro è inventarlo

– Alan Kay

I love the way how each and every discussion turns into the war of the frameworks. I have worked with BackboneJS and AngularJS quite extensively and have come across most of their short comings in production. So, you dont really have to take this analysis with a grain of salt. I would be happy to take back anything that I have said if it turns out to be wrong. Lets get to the meat of it, then, shall we?

Backbone vs Angular: Demystifying the myths

Ad EuroPython 2012 ho poi raccontato la nostra esperienza e condiviso ciò che avevamo imparato. In quell’occasione mi sono reso conto di quanto l’argomento fosse d’attualità, tanto che da quel 4 luglio le slide che avevo preparato (le trovate su Speaker Deck o Slideshare) ed i video su YouTube (italiano; inglese) hanno totalizzato 30mila visite. Da allora ricevo continue richieste di chiarimenti, suggerimenti, approfondimenti, consigli. Soprattutto, mi si chiedono esempi di codice. In fin dei conti prima o poi qualunque sviluppatore web si trova, volente o nolente, a fare i conti con una REST API.

Così ho pensato che avrei potuto prendere il nostro codice proprietario (nome interno Adam), sistemarlo un po’ in modo che si adattasse ai casi d’uso più comuni, e rilasciarlo come progetto open source. Be’ c’è voluto un bel po’ di lavoro, ben più di quello inizialmente preventivato, ma ora ci siamo. Il progetto è finalmente disponibile, e naturalmente si chiama Eve.

Costruire e lanciare una API con Eve è semplice. Servono tre cose; un database, un file di configurazione, uno script di lancio. MongoDB è già supportato; sviluppare estensioni per altri database SQL/NoSQL non dovrebbe essere troppo complicato. Le personalizzazioni della vostra API sono salvate in un modulo standard Python. Lo script di esecuzione è in genere davvero semplice:

Le API basate su Eve supportano l’intero range di operazioni CRUD (Create, Read, Update, Delete). Ogni end-point è personalizzabile e supporta filtri, paginazione e ordinamenti. Per massima accessibilità i client possono chiedere che le risposte pervengano in JSON oppure XML. Sono supportati gli inserimenti multipli, le direttive di caching per i client, il versioning e… tante altre cosette.

Non mi dilungo oltre poiché su GitHub trovate tutto quel che serve: documentazione (al momento piuttosto scarna), codice e progetti satellite. In particolare date un’occhiata a Eve-Demo, una API funzionante messa su in pochi minuti grazie a Eve. Potete consultarla direttamente, via cURL per esempio, o anche via browser (in questo caso vi beccherete del XML in risposta, mentre via cURL o altro potrete scegliere JSON). Il README di eve-demo include una serie completa di esempi relativi alle varie operazioni di lettura, inserimento, cancellazione, aggiornamento.

C’è ancora tanto da fare affinché Eve diventi il framework completo, stabile e maturo che ho in mente ma credo che il progetto ora sia pronto per una anteprima pubblica. In ogni caso sono lieto di dare finalmente risposta alle richieste di questi mesi: ora avete il codice; usatelo come volete. Spero anche e soprattutto di raccogliere critiche, consigli e suggerimenti; magari a qualcuno verrà anche voglia di collaborare!

PS: Buon 2013!

Python Tools per Visual Studio è un plugin gratuito e open source che trasforma Visual Studio in una IDE per Python. Supporta CPython, IronPython, Intellisense, Debugging, Profiling, Editing, Browsing, REPL Multipli, IPython, Django e Cloud Computing con librerie client per Windows, Linux e OS X (Azure).

La versione 1.5, rilasciata oggi, aggiunge supporto per Django, Azure, REPL debugging, Visual Studio 2012 e altro.

A margine dell’evento molte le domande su Eve, la REST API open source a cui sto lavorando e che conto di rilasciare entro fine anno: bene! Grazie a tutti i partecipanti ed a 10Gen per avermi invitato.

Sono due le caratteristiche che rendono Cerberus interessante: è facilmente estensibile (la documentazione include un esempio di estensione del sistema di convalida), e non si blocca sollevando un’eccezione al primo problema riscontrato: gli errori, quando presenti, sono tutti riportati in una lista a fine convalida.

Cerberus è un progetto open source tutt’ora in pieno sviluppo, al quale è possibile partecipare. E’ alla base del sistema di convalida impiegato dalla nostra REST API, ma può e dovrebbe vivere di vita propria – per esempio nei vostri progetti. A proposito, la stessa RESTful Web API, quella di cui ho parlato a EuroPython, sarà rilasciata come progetto open source. Stay tuned.

I’m happy that regular JavaScript can be written in TypeScript and still benefit from some of the type checking provided by the TypeScript compiler. That means writing TypeScript can actually help people learn JavaScript, which makes me happy.

Miguel de Icaza, il cervello dietro Xamarin e la piattaforma Mono, ha sintentizzato le sue prime impressioni sul progetto. Interessanti anche i commenti di uno degli sviluppatori di Dart, progetto Google dal quale TypeScript ha senz’altro tratto ispirazione.

Sviluppatori: passate ore, giorni, mesi, forse anni interi a perfezionare il vostro capolavoro. In fin dei conti si tratta dell’espressione di un’intera vita professionale, anima e cuore. Perché dunque vi fate del male dotandolo di documentazione scarna, o addirittura inesistente?

Write The Freaking Manual

Del problema della decodifica delle stringhe JSON in valori datetime ho già scritto in passato. Allora proponevo una soluzione algoritmica; ora vi presento un prodotto finito che potete usare nei vostri progetti.

Il problema

Lo standard JSON (RFC 4627) non supporta valori di tipo data/ora. In un flusso JSON le date vengono rappresentate come semplici stringhe che i decoder Python interpretano come tali:

import simplejson as json

>>>test = '{"name": "John Doe", "born": "Thu, 1 Mar 2012 10:00:49 UTC"}'
>>>json.loads(test)
{'name': 'John Doe', 'born': 'Thu, 1 Mar 2012 10:00:49 

Nell’esempio precedente il campo born è una stringa nel JSON, e tale rimane dopo la decodifica in un dizionario Python.

La soluzione

JSON-Datetime è un semplice wrapper attorno al metodo loads di simplejson. Ecco che succede quando usiamo JSON-Datetime al posto di simplejson:

>>> import jsondatetime as json
>>> test = '{"name": "John Doe", "born": "Thu, 1 Mar 2012 10:00:49 UTC"}'

>>> json.loads(test)
{'name': 'John Doe', 'born': datetime.datetime(2012, 3, 1, 10, 0 ,49)}

Ora born assume il valore corretto. Affinché vengano riconosciute, le date contenute nel JSON devono corrispondere a un formato strptime() valido indicato con l’argomento datetime_format. Nell’esempio precedente, poiché l’argomento è assente, viene usato il valore di default '%a, %d %b %Y %H:%M:%S UTC', corrispondente allo standard RFC 1123 (ex 822). Nell’esempio che segue usiamo un formato personalizzato:

>>> import jsondatetime as json
>>> test = '{"name": "John Doe", "born": "Thu, 1 Mar 2012"}'

>>> json.loads(test, datetime_format="%a, %d %b %Y";)
{'name': 'John Doe', 'born': datetime.datetime(2012, 3, 1)}

JSON-Datetime è un semplice wrapper che ci lascia liberi di usare tutti gli argomenti standard previsti per loads, object_hook incluso. Ciò significa che questa soluzione (al contrario di quella proposta in precedenza) ci lascia liberi di applicare qualsivoglia parser al nostro flusso JSON.

Installazione e sorgenti

Per l’installazione basta il classico pip install json-datetime. Il codice è disponibile su GitHub.

Liberamente tradotto da Thoughts on being a programmer.

E’ vero che non tutti i programmi Python richiedono un’analisi rigorosa delle prestazioni, ma è rassicurante sapere che l’ecosistema Python ci mette a disposizione una serie di strumenti a cui possiamo rivolgerci in caso di necessità.

Analizzare la performance di un programma significa prima di tutto rispondere a queste quattro semplici domande:

• Quanto gira veloce?
• Dove sono i “collli di bottiglia”?
• Quanta memoria sta utilizzando?
• Dove occorrono gli spechi di memoria?

Scopriamo come rispondere a queste domande attraverso alcuni strumenti molto interessanti.

A guide to analyzing Python performance è un’articolo non difficile che vale la pena leggere.

Soprattutto ho rilevato una forte curiosità su MongoDB, un database non-relazionale verso il quale sembra prevalere un atteggiamento  di generale timidezza: “vorrei ma non oso”, insomma. Per quanto riguarda Flask direi che ormai, nel vasto firmamento dei micro web framework, è una stella che brilla di luce propria.

Per quanto riguarda le registrazioni video potete andare su YouTube o sulla pagina ufficiale di EuroPython (english track e italian track). Ammetto di essere più soddisfatto della versione inglese nella quale – complice anche l’esperienza italiana del giorno prima – credo di essere stato più sintetico ed efficace. Qui mi limito a proporvi le slide:

Ringraziamenti

Un immenso grazie ai ragazzi dello staff di EuroPython che veramente hanno fatto di tutto per rendere questa manifestazione un evento straordinario – e ci sono riusciti  (una settimana di talk su cinque tracce parallele, sprint, hands-on, corsi, cibo di ottima qualità e credo oltre 800 partecipanti).

Vi racconto un episodio giusto per darvi l’idea di quanto questi ragazzi, tutti volontari, si diano da fare e ci mettano passione vera. Nella sessione italiana ho ‘sforato’ (capita anche ai migliori, mi dicono!) e così mi son trovato a sorvolare su un certo numero di slide. Ebbene il mio talk manager e il suo assistente mi hanno proposto di loro iniziativa di tenere una sessione pomeridiana straordinaria per consentirmi di portare a termine la mia relazione. Non capita tutti i giorni, credetemi. Per mia fortuna gran parte delle persone che avevano assistito alla sessione mattutina sono poi tornate per quella del pomeriggio, altrimenti sai che figura!

Se siete pythonisti o vorreste diventarlo non perdetevi la prossima edizione di questo evento internazionale che, con tutta probabilità, si terrà di nuovo a Firenze l’anno prossimo.

• Annuncio della versione 2.0 sul blog Sublime
• Come Kenneth Reitz ha configurato ST2 per Python
• Sublime Text 2 un anno dopo, il mio articolo più recente su ST2

PS: io nel frattempo sono tornato a vim, e per ora ci sto molto comodo. Sublime Text rimane l’editor che consiglio a chiunque non abbia già un background vi/vim e non voglia o non possa investire tempo nell’impararlo.

Il panorama mobile è monopolizzato da WebKit e di conseguenza gran parte degli strumenti e dell’infrastruttura per lo sviluppo di applicazioni frontend mobile (e non solo, ndr) risiedono nel WebKit Inspector. Per questo ne analizzerò con cura gli strumenti e spiegherò come e quando usarli.

Ci sono anche le slide.

Windows Azure ora supporta ufficialmente Python. La pagina ufficiale consente di scaricare l’SDK e contiene alcuni tutorial per la creazione di applicazioni Django, Python e IPython direttamente da Visual Studio.

fonte = '{"ragione_sociale": "CIR 2000", "aggiornato_il": "Wed, 06 Jun 2012 14:19:53 UTC"}'

Vediamo che succede se la convertiamo in un dizionario Python:

import simplejson as json

json.loads(fonte)
{'aggiornato_il': 'Wed, 06 Jun 2012 14:19:53 UTC ', 'ragione_sociale': 'CIR 2000'}

Facile, vero? C’è però un piccolo problema: aggiornato_il è ancora una stringa mentre a noi, per poterlo elaborare comodamente, serve un campo datetime.datetime. Come mai il pur potente modulo simplejson non converte correttamente la nostra data?

Il problema

Il fatto è che il JSON originale non fa nulla per informarci del fatto che il campo aggiornato_il esprime in realtà una data. La radice del problema sta nello standard JSON il quale non contempla la dichiarazione esplicita dei tipi di dati. In effetti la stessa questione si pone nella conversione di un numero non intero: va considerato un float, oppure un decimal? In quest’ultimo caso simplejson ci viene in aiuto con il parametro parse_float:

import simplejson as json

json.loads('1.1', parse_float=decimal.Decimal)
Decimal('1.1')

Purtroppo, per il motivo visto prima, non esiste un equivalente per le date.

La soluzione classica

In questi casi la prassi comune è rendere esplicito, già all’interno della stringa JSON, il formato del campo. Qualcosa del genere:

{"aggiornato_il": "$date: Wed, 06 Jun 2012 14:19:53 UTC"}

Così facendo possiamo in seguito manipolare il dizionario restituito dal metodo loads: intercettare la direttiva $date e sostituire finalmente la stringa con una data. Una soluzione più raffinata è quella di sfruttare l’opzione object_hook che consente di invocare una nostra funzione ad ogni chiamata del metodo loads.

La mia soluzione

Nel mio caso il provider JSON è esterno, e non desidero obbligarlo a pre-processare le stringhe JSON inserendo clausole $date arbitrarie solo per soddisfare le esigenze della mia applicazione. Sfruttando l’opzione object_hook già accennata ho ottenuto una soluzione del tutto trasparente:

fonte = '{"aggiornato_il": "Thu, 1 Mar 2012 10:00:49 UTC"}'
dct = json.loads(fonte, object_hook=datetime_parser)
dct
{u'aggiornato_il': datetime.datetime(2012, 3, 1, 10, 0, 49)}


def datetime_parser(dct):
    for k, v in dct.items():
        if isinstance(v, basestring) and re.search(" UTC", v):
            try:
                dct[k] = datetime.datetime.strptime(v, DATE_FORMAT)
            except:
                pass
    return dct

La funzione datetime_parser esamina gli elementi della stringa JSON. In caso di corrispondenza alla espressione regolare indicata in re.search tentiamo una conversione diretta al formato datetime. Data la specificità della espressione regolare la conversione dovrebbe avere successo. Il blocco try... except ci permette di ignorare un eventuale errore: in questo caso infatti presumiamo che si tratti di una stringa vera e propria e non, malgrado la somiglianza, di una data. L’unico vincolo imposto al provider JSON è l’adozione di un formato standard per rappresentare le date. Nel mio caso è il seguente:

DATE_FORMAT = '%a, %d %b %Y %H:%M:%S UTC'

Per approfondimenti vi consiglio:

• JSON econdoer and decoder
• Introduzione alle Regular Expression

Per completezza c’è da aggiungere che l’adozione di un json schema consentirebbe la specifica dei tipi di dati JSON. Quest’ultima soluzione però, data la sua complessità, non è applicabile nel mio e in molti altri casi.

PS: ne ho scritto anche su Stack Overflow.

Abbiamo abbandonato Moonlight (…) Il web non ha addotato Silverlight; non ha avuto il successo che mi aspettavo. Miguel de Icaza

Un’altro chiodo sulla bara di Silverlight. Dei dubbi sul futuro della tecnologia Microsoft avevo già scritto in occasione della sua mancata adozione in Windows 8 e al momento dell’annuncio di Silverlight 5.

Ogni giorno molti sviluppatori web usano SSH (“Secure Shell”) per gestire i loro server, fare backup, lavorare in remoto e una miriade di altre cosette. Oggi vi spiego cos’è e da dove viene SSH e, soprattutto, vi insegno come configurarlo sul vostro server remoto o sulla vostra rete locale. Cominciamo!

Annullare una commit

Se ancora non è stato stato eseguito il push verso un repo remoto:

In Git HEAD è la commit più recente mentre HEAD^ è la penultima (HEAD^^ è la terzultima). In alternativa è possibile indicare l’SHA-1 dell’hash della commit alla quale si vuole tornare, qualunque essa sia:

Il numero di hash di ogni commit è rintracciabile con un semplice git log --oneline

Differenza tra --soft e --hard

L’opzione --soft cancella la commit ma lascia i file invariati. Se volete riportare anche i file allo stato in cui si trovavano alla penultima commit:

Questo porterà “indietro nel tempo” il vostro repo, alla penultima commit. Sarà come se le ultime modifiche (e con esse l’ultima commit) non fossero mai esistite.

E se la commit è già finita nel repository?

Se la commit è già stata inviata a un repo remoto (push) è necessario seguire un’altra procedura:

Questo comando crea una nuova commit che annulla tutto ciò che è stato introdotto dalla commit indesiderata.

Sono un IM professionista da oltre 4 anni. Questo è il mio lavoro e lo faccio piuttosto bene. Ultimamente ho deciso di lanciare un sito di annunci italiano ed ho acquistato uno script pronto ed abbastanza complesso basato su joomla. Mi servono svariate modifiche sia nel frontend che nella admin panel (perlopiù semplificazioni) più la traduzione di tutte le voci presenti dall’inglese all’italiano.

Non sono un perditempo e non lavoro con gente mediocre o ragazzini ma solo con professionisti seri. Valuto la possibilità di far subentrare un socio/webmaster in questo progetto. Io mi occuperò della pubblicità/visibilità più inpage e offpage optimization e in generale del posizionamento mentre il socio avrà a che fare con degli aspetti prettamente tecnici e con tutte le migliorie da apportare di volta in volta al sito. Il candidato ideale deve avere buone conoscenze di joomla, php, html, javascript e possibilmente anche un po’ di ajax. Maggiori dettagli saranno forniti ai candidati che daranno prova di soddisfare le richieste sopra specificate.

• Tipo di committente: privato
• Nominativo committente: Michele
• E-mail: mikivv[at]aol.com
• Luogo di lavoro: telelavoro
• Tipo di contratto: freelancer/progetto (eventualmente webmaster/socio a tempo indeterminato)
• Budget massimo (riferito solo alle modifiche/traduzione frontend dello script): €1.000
• Valuto possibilità di assumere webmaster a tempo indeterminato o far subentrare socio nel progetto.

Partenza col botto per EuroPython 2012. I keynote introduttivi saranno tenuti nientemeno che dal creatore stesso del linguaggio, Guido Van Rossum, e da Alex Martelli. Ieri è stato annunciato il programma ufficiale e a quanto pare mi spetta l’inaugurazione della italian track martedì 3 luglio. Il giorno successivo sarò impegnato, ancora di prima mattina, con la versione in lingua inglese del mio talk:

Sviluppare una RESTful Web API con Python, Flask e MongoDB

Nel corso dell’ultimo anno abbiamo lavorato all’implementazione Python di una RESTful Web API completa. Abbiamo imparato un bel po’ di cose sui best pattern REST e, naturalmente, abbiamo messo alla prova le ben note capacità web di Python, rilasciando nel frattempo un paio di progetti Open Source. Nel corso del mio intervento condividerò quel che abbiamo imparato. Prenderemo in considerazione il problematico design di una REST API ‘pura’. Vedremo che cosa offre Python in questo campo e scenderemo infine nel dettaglio, dando una occhiata al codice che abbiamo scritto. Alcune tecnologie/stack che tratteremo sono (in nessun ordine particolare): Flask, PyMongo, MongoDB, REST, JSON, XML, Heroku. Lo sapevi? Che ti piaccia o no, c’è una REST API nel tuo futuro.

Scorrendo la lista degli speaker scopro che anche Amin Roacher, autore di Flask, e Ross Lawley di 10Gen (MongoDB) saranno della partita. Insomma ammetto che un po’ d’ansia da prestazione comincia ad affiorare. Sarà una bella sfida, e non vedo l’ora di affrontarla. Conto molto sul vostro supporto e incoraggiamento: ne avrò bisogno 😉

Git Immersion è un tour guidato che ti accompagna in una passeggiata tra i fondamenti di Git, ispirato dalla premessa che conoscere una cosa significa usarla. Git è un sistema potente e sofisticato per il controllo di versione distribuito. Per lo sviluppatore conoscere e comprenderne le caratteristiche significa aprirsi a un nuovo e liberatorio approccio alla gestione del codice sorgente. Il modo migliore per padroneggiare Git è immergesi nelle sue utility ed operazioni, sperimentarlo in prima persona.

EuroPython è la conferenza europea di riferimento per il linguaggio Python. Si terrà anche quest’anno a Firenze, dal 2 al 8 luglio. Sono in programma molti interventi davvero interessanti, cosa che rende ancor più soprendente il fatto che i miei talk siano stati votati così tanto.

Date un’occhiata al sito ufficiale per saperne di più sulla conferenza (in questo momento è ancora possibile approfittare dell’offerta early bird per l’acquisto dei biglietti); maggiori informazioni sui miei interventi tra qualche tempo, quando sarà ufficializzato il calendario dei talk.

MVVM (Model View ViewModel) è un pattern architetturale basato su MVC e MVP, che tenta di separare chiaramente lo sviluppo della interfaccia utente (UI) da quelle che sono business logic e comportamento dell’applicazione. A questo fine, molte implementazioni del pattern ricorrono a un uso dichiarativo dei data bindings, per consentire la separazione del lavoro sulle Viste (View) dagli altri strati (layer).

MVVM consente creazione di UI  e sviluppo del codice in parallelo, all’interno della stessa base di codice. Gli esperti UI scrivono bindings per il ViewModel all’interno del loro markup (HTML), mentre il Model e il ViewModel sono gestiti dagli sviluppatori che lavorano alla logica dell’applicazione.

Comprendere il MVVM – Guida per Sviluppatori JavaScript

Il meccanismo è quello della gamification, con tanto di punteggi e badge da conquistare man mano che si raggiungono obiettivi prefissati . Presto dovrebbe uscire anche un corso su Python.

Compi i tuoi primi passi con HTML e CSS. Non è necessaria alcuna esperienza precedente — cominceremo dalle basi e in poco tempo ti ritroverai a lavorare alla tua homepage personale!

Rainbow è una libreria per l’evidenziazione del codice scritta in Javascript. E’ leggera (1.4kb), facile da usare, estensibile e completamente configurabile via CSS.

Pochi sanno che il codice sorgente originale era andato perduto. Mechner l’aveva cercato ovunque senza successo, perdendo ogni speranza di rintraccialo. Finché, proprio ieri, suo padre non è sceso in cantina. Da un scatolone che conteneva confezioni sigillate del mitico Karateka (1984 – quante partite sul mio C64!) sono spuntate tre confezioni di floppy disk Apple ProDOS da 3.5″: contenevano il codice perduto.

La lieta novella si deve allo stesso Mechner, ora impegnato nel non banale tentativo di riuscire a leggere il contenuto dei vecchi floppy per poi trasferirlo sul suo MacBook Air. Su Flickr è stato pubblicato il set fotografico dei floppy disk originali.

Per i nostalgici della mia età (e per i giovani curiosi) ecco il filmato di una sessione di gioco del Prince of Persia originale: la fuga dalle prigioni del Califfo.

Aggiornamento: il codice sorgente di Prince of Persia è stato recuperato ed è ora disponibile su GitHub.

Sono felice di annunciare che oggi rilasciamo il codice sorgente di ASP.NET Web API e ASP.NET Web Pages (Razor) sotto una licenza open source (Apache 2.0), e che continueremo a migliorare la trasparenza di tutti i tre progetti ospitando il loro codice sorgente su CodePlex (usando il nuovo supporto per Git annunciato la settimana scorsa).

Ma quel che più conta, e che per un’azienda corporate ‘vecchia maniera’ come Microsoft denota davvero un’evoluzione (rivoluzione) culturale:

Per la prima volta consentiremo agli sviluppatori esterni a Microsoft di proporre patches e contributi di codice, che il nostro team di sviluppo valuterà per la potenziale inclusione diretta nei prodotti.

Amazon offre sconti significativi per chi sceglie le istanze riservate al posto di quelle on-demand. Dal punto di vista finanziario, e se avete intenzione di usare EC2 per almeno un anno, passare dalle istanze on-demand a quelle riservate potrebbe aver senso. Sborserete una cifra più alta inizialmente, ma il costo mensile si ridurrà sensibilmente.

Per quanto io ne sappia il tool sviluppato da Mike Khristo è il primo che consente di confrontare direttamente, senza tanti giri di parole, il costo delle due soluzioni:

Usare Dropbox come repository Git remoto

Recentemente, più che altro per curiosità, ho giocato con una terza opzione: Dropbox. Per me Dropbox è uno strumento indispensabile sia per il lavoro che per le mie cose personali. Su qualunque computer io sia, ovunque mi trovi, grazie a Dropbox ho accesso al mio materiale. Dunque, mi son detto, perché non usarlo anche per il codice,  pur senza rinunciare al controllo versione offerto da Git?

Ebbene ho scoperto che non solo è possibile, è anche molto semplice. In realtà non c’è nulla di nuovo in quel che vi mostro, la ‘magia’ la fa tutta Dropbox.

Creare un Git repository ‘remoto’ su Drobox

Se siete su Linux o Mac aprite una finestra terminale; su Windows aprite semplicemente Git Bash. Se avete una installazione predefinita la cartella Dropbox si trova nella HOME di Linux e Mac, oppure nella Documenti di Windows.

Spostatevi nella cartella Dropbox:

Una volta entrati in ~/Dropbox create un ‘bare’ repository:

Il nostro repository privato, l’equivalente di un repo remoto alla GitHub per capirci, è pronto. Lo useremo per tenere sincronizzati i nostri computer. Naturalmente appoggiarci a Dropbox ci garantisce anche la possibilità di ricorrere a un restore di emergenza nel caso il codice venga perduto localmente.

Creare il Git repository locale

Su ognuno dei computer creiamo il repository locale:

Lavoriamo un po’, quindi facciamo la nostra commit locale:

Ora colleghiamo il repo “remoto” (quello in Dropbox) al nostro repository locale:

Ora possiamo fare il push verso il remoto dei files locali. Dal branch [cci lang=”bash” theme=”default”]master[/cci] verso [cci lang=”bash” theme=”default”]origin[/cci]:

Fatto! Possiamo simulare facilmente il lavoro su un’altro computer. Basta clonare [cci lang=”bash” theme=”default”]progetto[/cci] dal ‘remoto’, cambiare qualche file e salvarlo:

Torniamo ora al folder locale originale. Possiamo sincronizzarlo e aggiornarlo con le modifiche fatte sul “secondo computer”:

Il versioning di Dropbox

Dropbox è dotato di un proprio sistema di versioning, pertanto aggiungere Git potrebbe sembrare superfluo. Qualunque sviluppatore avvezzo a Git vi dirà che non è così. Il versioning di Dropbox è adatto a file di testo, fogli di calcolo, immagini e quant’altro ma non ha niente a che vedere con le capacità di manutenzione e gestione dei progetti offerte da Git.

Git e Dropbox per gruppi di lavoro?

E’ sufficiente condividere il folder Dropbox con altre persone per creare un ambiente di sviluppo privato ma condiviso col proprio gruppo di lavoro. In quest’ultimo caso la probabilità di conflitti aumenta notevolmente. Si tratta di una soluzione forse interessante per mini-team di 2 o 3 persone nei quali è relativamente facile evitare la generazione di conflitti (evitare le push contemporanee).

Concludendo

BitBucket o GitHub (a pagamento) rimangono la soluzione ideale, e offrono molte funzionalità comunque assenti in Git+Dropbox (interfaccia web, wiki, issues, eccetera). Per piccoli progetti personali Dropbox offre una alternativa a buon mercato, rapida e comoda.

PS: se create un account Dropbox dal link dell’articolo, oppure da questo, ricevete 500BMB extra (e altrettanti ne otterrà il sottoscritto)!

Anni fa JavaScript era considerato più che altro una seccatura: produceva queste animazioni e trailer per il browser e poco altro. Ora tutto è cambiato. JavaScript è eletto a linguaggio funzionale di prima classe e in rete sono disponibili risorse innumerevoli . Condivido con voi alcune delle mie fonti migliori, che uso per tenermi aggiornato su librerie, progetti e JavaScript in generale. – Rob Bazinet

Una casa per gli sviluppatori Python che lavorano con Facebook. Gestiamo due repository su GitHub. facebook-sdk, un set di tools essenziali per lavorare con Facebook in Python. django-facebook, un plugin estendibile per costruire siti Django integrati con Facebook.

via @bacchilu

Vi propongo alcune delle caratteristiche che ne fanno, almeno per quanto riguarda il mio modo di lavorare, l’editor ideale.

Multi piattaforma

Sublime Text gira egualmente bene su OSX, Windows e Linux. Lavorando su Mac a casa e con Windows in ufficio per me è sempre stato difficile trovare un editor di codice di alta qualità da poter usare in entrambi gli ambienti. TextMate? Solo per Mac. Notepad++? Solo per Windows. Si lo so che Eclipse e altre IDE sofisticate sono multi piattaforma ma il fatto è che io le IDE non le sopporto più. Le ho usate per vent’anni, e tuttora sono vincolato a Visual Studio (un prodotto comunque eccellente) per gran parte del mio tempo. Da quando sono potuto tornare alle origini, ovvero ai semplici text editor, mi ci rifugio appena possibile.

Bisognerebbe poi intendersi sul quel ‘semplici’ perché come vedremo Sublime Text e gli altri editor, moderni e non, sono semplici solo in apparenza.

Una critica a Sublime Text 2 multi piattaforma mi sento di farla, e riguarda la non completa uniformità dei menu tra le diverse piattaforme. Per esempio le Preferenze sono  nel menu principale in OSX, mentre se ricordo bene in Windows stanno in ‘Tools’.

Command Palette

Come dicevo Sublime Text 2 è ricco di funzionalità, la gran parte attivate da menu con gran lavoro di mouse. Esistono le scorciatoie di tastiera per i comandi più frequenti, ma Sublime ci mette a disposizione qualcosa di più, la Command Palette.

Premete Shift-Command-P per ottenere l’apertura della Command Palette:

La lista contiene i comandi disponibili in Sublime. Basta scrivere anche solo una parte del nome del comando per ottenerne la rapida selezione. Per attivarlo basta premere Invio. Si tratta di una soluzione davvero comoda, alla TextMate, che risparmia il mouse ed è ben implementata. Nell’immagine vedete come per installare un nuovo package mi basti premere una lettera (la ‘i’), anche se non è quella iniziale.

Passaggio rapido da un file all’altro

Ogni file aperto è contenuto in una scheda. Possiamo passare da un file all’altro cliccando sulle schede oppure usando la tastiera per scorrerle in sequenza. Ma possiamo anche ricorrere al comando Command-P per aprire una palette di selezione file, la quale implementa la stessa modalità di ricerca già vista nella Command Palette:

Ciò che rende questa palette davvero utile è il fatto che man mano che scriviamo Sublime attiva (mette in primo piano) il file che soddisfa la nostra query. Dopo un paio di volte non potrete più tornare al mouse.

Cursore multiplo

Immaginate di selezionare più aree del codice e trattarle come se fossero tutte sotto un unico cursore. Ebbene è possibile, ed impagabile. Potete vedere questa modalità all’opera nel breve screencast messo a disposizione dai ragazzi di NetTuts, io mi limito a spiegarvi le alternative per attivarla:

• Premere Command e cliccare nei punti in cui volete attivare il cursore multiplo
• Selezionare blocchi di testo e premere Shift-Command-L
• Mettere il cursore sotto una parola e premere Command-D per selezionarne le occorrenze successive attivando il cursore per ognuna
• Selezionare una parola e premere Control-Command-G per selezionarne tutte le occorrenze attivando per ognuna il cursore

Passaggio rapido a funzioni e metodi

Oltre alle funzioni di ricerca classiche possiamo passare rapidamente da un metodo all’altro ricorrendo alla magica command palette vista prima. Basta Command-R per attivarla:

In Visual Studio ho sempre odiato il passaggio tra funzioni/metodi/classi implementato col solo match delle lettere iniziali, e addirittura suddiviso in due combo diverse (una per gli oggetti, l’altra per i metodi). Qui siamo a tutto un’altro livello.

C’è Vim dentro

Chi è abituato a Vim non disperi: è possibile attivare la modalità ‘Vintage’ che attiva il key binding del famoso editor Unix. Magicamente abbiamo a disposizione Command e Insert mode e molti dei comandi di editing più comuni in Vim. Per informazioni consultate la pagina sul Vintage Mode della documentazione.

E c’è pure un po’ TextMate

Temi e bundle di TextMate funzionano in Sublime Text, basta metterli nel folder Packages. Se siete legati a TextMate valutate la possibilità di passare a Sublime, potrebbe valerne la pena.

Package Control

Sublime è ricco di estensioni (package) e consente di installare quelle TextMate. Il Package Control (da installare a parte) rende facile la loro gestione direttamente dalla Command Palette.

Concludendo

Naturalmente non è tutto qui. Ampia scelta di temi custom e standard (io uso Monokai Soda), Plugin come se piovesse (tra i quali uso abitualmente quelli per Git e StackOverflow), modalità ‘distraction free’ e full screen, personalizzazione dei key binding, syntax highlighting di tutti i linguaggi più diffusi… ci sarebbe ancora tanto da dire.

Ammetto che molte di queste caratteristiche non sono una esclusiva di Sublime Text 2, tuttavia quel che apprezzo in questo prodotto è la velocità e l’immediatezza con le quali queste sono utilizzabili. Cerco di usare il mouse il meno possibile e con Sublime riesco a fare tutto senza metterci mano, il che aumenta la mia produttività. Come ogni buon editor Sublime non interferisce con la scrittura del codice ma, quando serve, è pronto a dare una mano con una ricchezza di strumenti invidiabile.

Spero di avervi convinto a dare una occhiata. Sublime Text 2 è a pagamento, anche se la modalità demo non è a tempo e si limita a proporre l’acquisto ogni tanto.

Vi lascio con l’invito a dare un’occhiata al video di Andrey Tarantsov sul suo Workflow con Sublime Text. Ha riscosso molto successo quando l’ho segnalato su Twitter, e per un buon motivo.

“Why are so many developers so very emotional when it comes to their favourite programming language? Considering that no language can (yet) magically translate the perfect idea in your head into machine code, all of them exist on a scale of badness – they all limit you more than your own thoughts or the hardware does.”

“Clean, simple web designs have become a popular trend. This article will cover the subject through a two-part discussion. First, we’ll talk about a few traits that clean designs tend to have in common. Secondly, I’ll share some tricks and techniques that can be helpful when trying to achieve a clean design.”

Database of HTTP status codes with their IETF and Wikipedia descriptions

“What happens when you click on a weblink? Here’s one answer: a request goes from your computer to a server identified by the URL of the desired link. The server then locates the webpage in its files and sends it back to your browser, which then displays it on your screen. Simple.”

“We occasionally try commercial software. Mostly, we don’t end up buying it. A big reason why is the incredibly time-consuming, aggravating sales process that most commercial enterprise (that is, non-consumer) software vendors insist on.”

“My experience of learning how to write iOS software, after having spent many years exclusively in the world of .NET development. It provides warnings, suggestions, and tips for others who are interested in learning iOS development.”

“If you write any code in JavaScript then you’ve probably used closures, but do you actually understand what they are and how they work? Taking the time to understand closures and how they’re implemented can add a deeper dimension to your understanding of the JavaScript language.”

“In desktop applications, the user interface dominated the screen. The buttons to click, the bars to drag, the windows. That isn’t the case with mobile devices. What’s powerful about mobile devices is that they exist to complement what we are already doing, rather than be our primary focus.”

“At Stack Overflow (…) we feel that it’s part of our mission to help lead fellow .NET developers — and the most effective way to do that is by contributing some of the code that we use to build Stack Overflow and Stack Exchange back to the greater .NET developer community as reusable open source packages.”

“We’ve made a selection of indispensable resources like layout frameworks, tutorials, books, templates and useful tools that can help you understand and implement grid based design in your projects.”

Tutto ciò significa che l’installazione di Flask MimeRender su Windows, OSX e Linux è diventato più semplice:

Codice sorgente e istruzioni sono a vostra disposizione su GitHub, mentre per spiegazione approfondita ed esempio d’uso vi rimando al mio articolo precedente: Una REST API che adatta le sue risposte al MIME Media-Type delle richieste HTTP.

Una delle specifiche REST più importanti vuole che un servizio RESTful sia in grado di fornire dati in più formati, in modo tale da soddisfare il maggior numero possibile di utenti/applicazioni. Immaginiamo un servizio che fornisce i risultati delle partite del campionato di calcio. Supponiamo che arrivino tre richieste successive per lo stesso risultato: la prima potrebbe chiedere una risposta in formato XML, la seconda in JSON e la terza in HTML. Il  nostro servizio deve rispondere a tutte e tre le richieste, adattando il flusso di dati della risposta al formato di ognuna.

Nel mio caso la API che sto implementando supporta XML, JSON, HTML e testo puro. E’ scritta in Python (ma va!) e si appoggia all’eccellente Flask micro web framework. Per risolvere in maniera elegante il problema delle risposte multi-formato ho deciso di usare i decorator, una delle caratteristiche più interessanti di Python. Dopo un po’ di lavoro in proprio ho scoperto che qualcuno aveva già risolto il problema, per giunta con la stessa tecnica. MimeRender di Martin Blech è un’ottima soluzione, solo che è specifica per web.py (un altro web framework). La mia soluzione non disponeva di alcune opzioni interessanti che MimeRender include; ho deciso allora di scrivere un port di MimeRender per Flask, e di metterlo a disposizione del pubblico.

Istruzioni per l’uso

Prima di tutto è necessario fornire le funzioni da usare per il rendering, una per ogni formato che intendiamo supportare:

Quindi decoriamo la nostra funzione, definendo per lei la mappa delle funzioni di rendering:

Tutto qui! In caso di richiesta GET la funzione index restituisce un dizionario, il quale verrà reso da MimeRender come XML, JSON o quant’altro, a seconda del Content-Type specificato nella richiesta HTTP:

Su github trovate l’esempio completo nonché il codice sorgente del renderer, che potete scaricare liberamente.

Ho cominciato a lavorare alla traduzione autorizzata dell’ottimo The Little MongoDB Book di Karl Seguin. Ho scovato il libro di Karl mentre raccoglievo la documentazione per un nuovo progetto super-segreto (!) a cui sto lavorando. Lo ritengo un’ottima introduzione al mondo NoSQL in generale e naturalmente al fantastico MongoDB.

Il titolo italiano sarà Il Piccolo Libro di MongoDB. La traduzione prosegue costante ma a piccoli passi perché purtroppo o per fortuna di tempo libero ne ho poco. Al momento sono tradotti più o meno grossolanamente l’introduzione e il primo capitolo. Mi farebbe comodo un po’ di aiuto, in particolare per quanto riguarda la revisione del testo. Se qualcuno vuol dare una mano è il benvenuto: potete fare delle pull request direttamente su GitHub (metodo preferibile), oppure mandarmi le correzioni via mail. In cambio vi prometto una menzione d’onore e l’eterna gratitudine dei futuri cultori italiani di MongoDB!

A lavori ultimati rilascerò il Piccolo Libro di MongoDB nei formati PDF, ePub, .mobi e probabilmente HTML. Se avete commenti o suggerimenti in proposito fatemelo sapere!

Una domanda facile da formulare, che presuppone un’altrettanto facile risposta. Ahimè non é così semplice, perlomeno non nel mio caso. Certo, ci sono dozzine di fonti di ottima qualità, ma penso che per poter fornire un consiglio valido dovrei conoscere meglio chi pone la domanda. Il tuo background è scientifico o umanistico? Sai l’inglese? La gran parte delle fonti che consiglierei sono inglesi. Qual’è la tua età? Sono tanti i fattori da considerare, soprattutto se ci si impunta a voler rispondere con cura.

In tempi non troppo lontani programmare significava conoscere il funzionamento dei computer; comprendere a fondo la loro teoria e la loro struttura. Ora è tutto cambiato. Ormai Assembly e Linguaggio Macchina sono domini riservati a pochissimi super-specialisti; la gran parte dei programmatori più giovani li ha solo sentiti nominare. I linguaggi ad alto livello ci permettono di concentrarci sulla soluzione dei problemi (gli algoritmi) delegando al compilatore la creazione delle istruzioni di basso livello.

E’ una buona notizia. Per diventare programmatori non è indispensabile essere particolarmente dotati, né seguire chissà quali corsi accademici. Buona volontà, curiosità, passione e un pizzico di intraprendenza sono tutto quel che serve per buttarsi. Se son rose fioriranno, come si suol dire.

Pensare da Informatico

Se mi avete seguito fin qui grazie per la pazienza. Vi ricompenso con lo stesso consiglio che ho dato a Mirko l’altro giorno: Pensare da Informatico. Ma come direte, dopo tutte queste chiacchiere ci spiattelli un’altra astrattezza da quattro soldi? Al contrario! Sto parlando di un libro vero e proprio. Pensare da Informatico (Versione Python) è l’unico testo che mi sento di consigliare davvero ai principianti. E’ gratuito ed è ottimamente tradotto da Alessandro Pocaterra. L’edizione originale è giunta da poco alla terza edizione (novembre 2011), mentre credo che l’italiana sia ferma alla seconda, che va benissimo comunque.

Nella Prefazione Jeff Elkner racconta che era alla ricerca di un testo adatto all’insegnamento della programmazione nelle scuole americane. Il grande Richard Stallman gli consigliò di dare una occhiata a How to Think Like a Computer Scientist:

Quando lessi quel libro seppi immediatamente che volevo usarlo nelle mie lezioni. Era il testo di informatica più chiaro ed utile che avessi visto: il libro enfatizzava il processo di pensiero coinvolto nella programmazione piuttosto che le caratteristiche di un particolare linguaggio. Il solo fatto di leggerlo mi rese un insegnante migliore.

Mica male come premessa no? Python è il inguaggio scelto dagli autori (e in proposito vi consiglio di leggere introduzione e prefazione) ma davvero non è il linguaggio quel che conta. Leggete questo testo con attenzione e soprattutto senza fretta. Non passate al capitolo successivo se non siete sicuri di aver afferrato per bene ciò che avete appena letto. Si procede passo per passo affrontando tutti i principali temi della programmazione moderna. Vi assicuro che alla fine di questa esperienza saprete programmare a dovere, a prescindere dai linguaggi che in futuro vorrete studiare (e magari nel frattempo vi innamorerete pure di Python).

Fatemi sapere come è andata. Ci tengo molto.

Aggiornamento del 9.3.2012. Ho scovato per caso una versione PDF, ben fatta, di Pensare da Informatico.

A spiegarlo al mondo è stato naturalmente Douglas Crockford in JavaScript: The Good Parts, un libretto di 172 intensissime pagine in cui si ha costantemente la sensazione che l’autore intenda demolire il linguaggio mentre, in realtà, non fa altro che esaltarne le doti. JavaScript è il linguaggio più usato al mondo, e non a caso: è l’unico supportato da qualunque browser del pianeta. La recente affermazione di Node lato server ne dimostra l’indiscussa attualità.

Ciò nonostante JavaScript rimane un linguaggio inadatto al programmatore neofita. O forse no.

John Resig e la Khan Academy

John Resig è il creatore di jQuery. Vera star internazionale, autore di libri di successo, ora lavora per Khan Academy, la famosa accademia online. Ecco ciò che Resig ha annunciato poco prima di Natale:

Alla Khan Academy stiamo considerando nuovi, originali, metodi di insegnamento della Computer Science. L’aspetto più interessante è che proporremo agli studenti JavaScript come loro primo linguaggio.

La sua è una situazione particolarmente vantaggiosa: oltre a essere completamente digiuni di programmazione i suoi studenti hanno appena completato un corso di matematica e scienze.

In effetti insegnare l’ereditarietà prototipale (prototypal inheritance) caratteristica di JavaScript a programmatori già abituati alla tradizionale ereditarietà degli oggetti richiede un certo impegno. E’ senz’altro più semplice spiegarla a chi non sa nemmeno cosa sia l’ereditarietà in informatica. JavaScript è anche un buon linguaggio per la programmazione funzionale, anche questa più facile da capire in assenza di condizionamenti precedenti. In questo filmato Resig parla del suo progetto sottolineando quello che probabilmente è il più grande vantaggio di JavaScript, la sua ubiquità:

Resig non si nasconde certo le difficoltà, tanto che nel suo articolo si dilunga nella spiegazione di una serie di accorgimenti didattici e tecnici che dovrebbero semplificare il processo di apprendimento.

Parliamone

Il progetto è senz’altro interessante e non c’è dubbio che JavaScript sia un ottimo investimento. Non sono sicuro però che partire da JavaScript sia l’approccio migliore per imparare a programmare. L’obiettivo iniziale dovrebbe essere, io credo, imparare le basi della programmazione a prescindere dal linguaggio. Non sarebbe meglio sceglierne uno senza troppe bad parts, dotato di sintassi più semplice, applicabile a contesti diversi e non solo al web?

Chi mi legge sa della mia predilezione, per altro criticata aspramente da più parti, per Python come linguaggio didattico. Per altri motivi andrebbe bene anche un super-classico come il linguaggio C oppure, perché no, un linguaggio funzionale puro come Haskell. JavaScript? Assolutamente si, ma come secondo linguaggio.

Mi domando infine, e qui ci metto un pizzico di malizia, se la scelta di Khan Academy non sia stata influenzata dalla passione per JavaScript del suo super-consulente, a prescindere da ogni valutazione didattica. Voi che ne pensate?

Git è un sistema di controllo versione ideato da Linus Torvald (quello di Linux). E’ gratuito, multi-piattaforma, distribuito e soprattutto talmente veloce che sembra aggiungere un pizzico di magia al processo produttivo. Git è una macchina del tempo con cui spostarsi avanti e indietro tra le versioni del codice. E’ l’ideale sia per progetti individuali che per gruppi di lavoro numerosi e distribuiti. L’integrità del codice e la preservazione delle versioni sono garantite da un efficiente – e veloce! – sistema di branching e merging.

Se non avete mai usato prima un sistema di controllo versione (e magari ricorrete ancora a copie manuali del codice tra una release e l’altra) gioite, perché Git vi cambierà la vita. Se venite da altri sistemi (Subversion, Team Foundation Server) sappiate che Git adotta un approccio fondamentalmente diverso: niente copie differenziali. In Git ogni repository è un mirror integrale della codebase; è quest’accorgimento ciò che rende Git così veloce.

Come e dove imparare Git

Git non è difficile, ma richiede un pò d’impegno iniziale. In rete sono disponibili numerose e ottime fonti. Vi consiglio Git Pro, libro gratuito nella versione online. Stampatelo e tenetelo sempre a portata di mano. Ottimi anche Git Reference e Everyday GIT (consigliati dal sito ufficiale), Git Magic per quando avrete già un pò di dimestichezza con Git, e infine la valida raccolta che trovate su Stack Overflow.

La potenza è nulla senza controllo

Uno dei risultati più interessanti che abbiamo ottenuto grazie all’adozione di Git è la pubblicazione contemporanea di più versioni del nostro software gestionale. C’è quella ufficiale (stabile) e c’é quella sperimentale con una anteprima delle novità a cui stiamo ancora lavorando. E’ un pò la nostra _night build e _contiene le cose non ancora mature per affrontare il grande pubblico ma già interessanti per gli utenti più smaliziati. Nel frattempo lavoriamo anche a nuove funzionalità importanti. Queste ultime vedranno la luce solo in occasione dei rilasci più significativi (tipicamente non sono più di due o tre all’anno) e non sono incluse nelle night build. In tutto questo bailamme di versioni, hotfix e rilasci pubblici e interni non perdiamo una linea di codice e manteniamo i nostri repository allineati, muovendoci avanti e indietro quando necessario.

Per ottenere un risultato così non basta il sistema di controllo versione; è necessaria anche una ottima strategia o, per meglio dire, un modello di branching ben progettato. Dopo diversi tentativi andati più o meno a vuoto la soluzione è arrivata grazie alla scoperta dello spettacolare articolo di Vincent Driessen:

Il modello si basa su due branch principali (master e develop) e su tre di supporto (hotfix, feature e release). Lo considero talmente valido che mi sono proposto a Vincent come curatore della traduzione italiana, solo per scoprire che qualcuno prima di me ci aveva già pensato: meglio così. Da quando l’ho scoperto lo applichiamo con zelo e vi consiglio di fare altrettanto, soprattutto se lavorate su progetti complessi.

Non solo codice

Git è utile anche per i piccoli progetti personali. Anzi, se state cominciando vi consiglio di partire proprio da uno di questi. Non è necessario che sia un programma, potrebbe benissimo trattarsi di un file di testo qualunque. Git funziona con qualunque tipo di file e in effetti viene usato con successo per progetti di scrittura, documentazione, web design e quant’altro.

Una volta presa dimestichezza con Git non potrete più rinunciarvi, qualunque sia la portata del progetto a cui state lavorando.

Il soggetto scelto dal team erano le onde del mare e ben presto si pose il problema di rappresentarle realisticamente. Un insegnate di Matematica suggerì di ricorrere alla teoria dei frattali. Idea brillante che offriva l’opportunità di un approfondimento didattico piuttosto insolito per un liceo artistico.

Le competenze informatiche del nostro intraprendente professore risalivano credo ai tempi dell’università, e i ragazzi erano a digiuno di qualunque nozione tecnica. Nel corso della discussione mia moglie, più che altro per associazione d’idee, buttò lì una frase:

mio marito è un gran sostenitore del linguaggio Python, dice sempre che è l’ideale per imparare e che dovrebbero insegnarlo nelle scuole

La cosa sembrava finita lì senonché dopo qualche giorno il professore irruppe in sala insegnanti, puntò dritto su mia moglie e l’apostrofò così:

ho scritto questo programmino in Python, non è che tuo marito può darci una occhiata perché sai funziona, ma non disegna proprio il frattale che serve a noi – ci va vicino

Immaginate la mia sorpresa quando la sera, a casa, mia moglie mi raccontò tutta la faccenda. La mia prima reazione è stata quella di correre al computer per dare un’occhiata al codice:

Mi sono subito reso conto che si trattava di una implementazione parziale della Curva (o fiocco) di Koch, una delle prime curve frattali documentate e anche una delle più famose. Una volta corretto il problema l’output restituito dal programma è stato questo:

Non male davvero. Per ammissione dello stesso autore sappiamo che il codice era in parte scopiazzato (in rete si trovano implementazioni della curva di Koch in tutti i linguaggi), ma non è questo il punto.

Il fatto è che un professore di uno sperduto liceo artistico (artistico!) italiano ha:

1. adottato Python per una lezione in classe
2. dimostrato che nella scuola ci sono anche (molti) docenti intraprendenti, appassionati e competenti

Qualche mese più tardi un’altra docente, che mi chiedeva consiglio su come approcciare la programmazione in classe, ha rifiutato categoricamente la mia proposta di Python perché “non l’aveva mai sentito nominare”. Scelse invece il linguaggio C perché “molto più affermato”.

Senz’altro, anche se nutro seri dubbi sul fatto che la sua scelta sia la migliore da un punto di vista didattico. Dubito, per esempio, che dopo un giorno o due lei e i suoi studenti sarebbero stati in grado di scrivere un’implementazione C della curva di Koch.

Diversi partner e clienti mi hanno detto di aver saputo da fonti Microsoft che Silverlight 5 è l’ultima versione di Silverlight che Microsoft rilascerà. Riferiscono di non sapere se verranno rilasciati Service Pack, né per quanto tempo Microsoft supporterà Silverlight 5

Si tratta solo di voci ma la fonte è autorevole. Proprio l’altro giorno Adobe ha annunciato lo stop allo sviluppo di Flash Player Mobile per concentrarsi su HTML5. Il vice presidente Adobe Danny Winokur ha dichiarato

Questa novità ci permetterà di aumentare l’impegno su HTML5 continuando a innovare Flash nei settori in cui  può avere più impatto: advanced gaming e premium video.

Non so voi ma io in queste righe io leggo qualcosa di più del semplice abbandono della versione mobile di Flash. Ci vedo la ricollocazione di Flash in settori di nicchia e la contestuale adozione di HTML5 come soluzione universale per il Web. Una onorevole resa delle armi, insomma.

Solo la scorsa estate facevo presente che sul futuro di Silverlight si stavano addensando nubi minacciose e tra le fonti citavo proprio la Foley. Sulla diatriba tra Flash e HTML5 ho già espresso la mia opinione sollevando anche qualche piccola polemica.

Non mi sorprende la inevitabile convergenza verso HTML5. Mi colpisce piuttosto la forte accelerazione subita dal processo, una accelerazione dovuta in gran parte proprio all’iniziativa di quegli stessi brand (e gliene va reso merito) che fino all’altro giorno resistevano all’avvento di HTML5. Ufficialmente Microsoft non ha ancora cambiato posizione, ma è solo questione di tempo.

Se il biennio 2010-11 è stato quello della battaglia per il web, il 2012 sarà senz’altro il primo del lungo e pacifico dominio di Re HTML5.

Approfondimenti

• Adobe Flash è una pessima idea
• Windows 8 è i dubbi sul destino di Silverlight

Per informazioni su Python Tools per Visual Studio date una occhiata a Programmare in Python con Visual Studio 2010 e Python Studio per Visual Studio 1.0.

Notizie di questo tipo vanno prese con beneficio di inventario anche se in questo caso una conferma indiretta viene da WANTED Analytics, che a Settembre ha pubblicato un report indipendente che sembra giungere alle stesse conclusioni. Anche i commenti all’articolo di TechCrunch sono confortanti: ci sono aziende che ammettono di essere a caccia di sviluppatori .NET e ci sono programmatori che confermano di ricevere continuamente offerte di lavoro (non mancano quelli che sono passati ad altri linguaggi e non se ne pentono).

Perché la carenza di Programmatori .NET?

Secondo TechCrunch gli sviluppatori .NET tendono a spostarsi su altre piattaforme perché temono di rimanere tagliati fuori dal mercato, visto che la tendenza del momento vuole i linguaggi open source far la parte del leone. Ci sarebbe inoltre una motivazione economica. Secondo Dice negli Stati Uniti i programmatori .NET guadagnano in media $83.000, mentre quelli Java arrivano a $91.000.

E in Italia?

Per quanto ne so non esistono dati sulla situazione italiana (se ne sapete qualcosa fatemelo sapere: li segnalerò volentieri). Un mio rapido test ha prodotto risultati incoraggianti: oltre 30 pagine di offerte di lavoro in ambito .NET. Non mi intendo di recruitment ma senz’altro è facile rilevare che, come negli Stati Uniti, anche da noi girano migliaia di applicazioni legacy .NET che assicureranno continuità di impiego anche nel lungo periodo. Probabilmente, ma si tratta di una mia sensazione, nel nostro paese la piattaforma Microsoft è meno diffusa in ambito Enterprise. Senz’altro la media dei salari IT europei (e italiani soprattutto) è più bassa di quella americana.

Anche da noi la tendenza è comunque verso l’open source e d’altra parte la stessa Microsoft si muove da anni anche in questa direzione pur senza intaccare il suo modello di business principale. Tempo fa mi sono dilungato sul perché le web startup non amano il .NET Framework e tutto sommato credo che quelle conclusioni siano valide tutt’ora. Certo mi fa piacere apprendere che la piattaforma sulla quale ho investito oltre quindici anni di carriera sta vivendo, almeno dal punto di vista del recruitment, una seconda giovinezza.

La diretta è stata seguita da oltre 1200 spettatori mentre in sala erano presenti circa 150 persone: un bel successo.

Per quanto riguarda le slide, visto che si trattava di un intervento di tipo Ignite ho preferito impostarle come semplice supporto al parlato (un paio sono addirittura ‘mute’):

Ringraziamenti

Grazie a Nicola Ballotta e tutti i ragazzi dello staff del KnowCamp, a Nicola Mattina e Gianluca Diegoli moderatori di Ignite Session e User Panel e un saluto affettuoso ai compagni di scorribande alimentari e non (voi sapete). Grazie al pubblico che mi ha dedicato cinque minuti del suo tempo.

Infine un grazie grande come una casa ai tanti che personalmente o via twitter/facebook oppure citandomi nei loro articoli online mi hanno comunicato il loro apprezzamento. Ripropongo uno dei riscontri che più mi hanno colpito perché testimonia che i contenuti proposti stanno attecchendo. Cosa può desiderare di più un umile relatore?

Non acquisterò la biografia ufficiale di Steve Jobs. Non mi interessa il suo privato e quel che ha (o non ha) fatto nel corso della sua carriera è di pubblico dominio. I contenuti del libro li troverò comunque citati, acclamati e commentati ad nauseam sul web. Gratis.

E poi, non fosse morto l’altro ieri, l’avrei comprata? Vedi sopra.

Più che una guida, Python for the Web è un appetizer che vi invoglierà ad approfondire gli argomenti trattati. Se state cominciando con Python, date una occhiata.

Luogo comune vuole che i programmatori siano persone chiuse, a volte timide, oppure scontrose e irascibili; più interessate al codice che non alle relazioni interpersonali.  E’ pur vero che il nostro lavoro richiede concentrazione. Molti sostengono che programmare è una forma d’arte e la gran parte degli artisti (pittori, scultori, disegnatori) non lavora forse in silenzio?

Tuttavia anche i più abili nell’eludere ogni forma di contatto prima o poi si vedranno costretti a comunicare con una persona importante: il cliente. Di tutte le forme di comunicazione professionale, quella col cliente è senz’altro la più delicata. Ne va del nostro lavoro e purtroppo in questo caso ci troviamo spesso ad affrontare un problema importante, quello che Chris Eidhof definisce la “perdita di segnale”.

Ogni volta che comunichiamo c’è un rumore di fondo. Se le parti hanno competenze diverse, frammenti del messaggio andranno perduti. In linea generale, più le esperienze sono vicine (due programmatori che parlano tra di loro), minore è la perdita di segnale.

Quando le aree di competenza sono divergenti (come capita tra programmatore e cliente) è necessario adottare, a volte forgiare, un linguaggio comprensibile per entrambi. Quasi sempre questo è più vicino al cliente che non al programmatore, per il quale l’impegno è notevole. Il rischio da evitare sono le incomprensioni e i conseguenti, inevitabili, ritardi nel lavoro.

A differenza dei linguaggi di programmazione, che una volta acquisiti entrano definitivamente nel bagaglio del programmatore, i linguaggi da adottare coi clienti tendono a cambiare di volta in volta a causa delle variabili in gioco, prime tra tutte il grado di alfabetizzazione informatica e l’area di competenza (ambito professionale) della controparte.

Qualche esempio può essere utile. Godetevi le mie tre gaffes più recenti, non tutte avvenute sul lavoro. D’altronde questa faccenda della scelta del linguaggio giusto non è certo confinata al solo ambito professionale. La prima riguarda la mia non proprio brillante comunicazione su Facebook:

Il secondo incidente è avvenuto proprio su questo sito:

In quest’ultimo caso si potrebbe obiettare che l’errore è del visitatore che è capitato nel posto sbagliato. Non è così perché l’avevo indotto io alla visita, pubblicando il link su Facebook. E veniamo al caso più interessante perché ha coinvolto un mio cliente la settimana scorsa:

Qui il nostro servizio di assistenza si era espresso chiaramente. Il fatto è che la parola ‘immagine’ ha un significato ben diverso a seconda che venga intesa da un tecnico informatico o da un commerciante di liquori. Pur avendo compreso perfettamente la richiesta, evidentemente non avrebbe avuto idea di come soddisfarla. Direi che in questo caso ha saputo arrangiarsi brillantemente. In effetti il supporto tecnico è uno dei campi nei quali il conflitto tra competenze e linguaggi diversi tende a generare i risultati più disastrosi.

Descrivere il problema col giusto linguaggio è il primo passo, forse il più importante, per trovarne la soluzione. Apprendere il dizionario del cliente è determinante per attivare una comunicazione efficace. Temo che nella gran parte dei progetti software non ci si provi nemmeno, e forse per questa ragione tanti programmi risultano difficili da utilizzare.

Premio Turing nel 1983 e National Medal of Technology nel 1999, Dennis Ritchie è conosciuto ai più come co-autore di uno dei libri più importanti (e venerati) nella storia della programmazione: The C Programming Language, o K&R come tutti l’abbiamo chiamato per trent’anni. La rilevanza del K&R è tale da renderlo ancora oggi uno dei libri di riferimento, consigliato a chiunque voglia diventare un programmatore o desideri scrivere di programmazione.

Per me Dennis Ritchie è sempre stato, con pochissimi altri, un vero e proprio mito. Lo saluto con affetto e gratitudine prendendo a prestito le parole di James Grimmelmann:

His pointer has been cast to void *; his process has terminated with exit code zero

Il titolo provvisiorio del mio intervento è Fuga dalla Comfort Zone. Ammetto di essere piuttosto nervoso. Il rischio di impappinarmi nel corso di quest’esibizione-rap è notevole, e tuttavia sono curioso di vedere come andrà a finire.

Al momento in cui scrivo il programma degli interventi è in definizione, ma sono già online i programmi del Business Panel e della Tavola Rotonda sulle Startup di domenica. L’evento sarà trasmesso in diretta streaming sui portali Wired Italia e Ninja Marketing. In ogni caso se ci sarete fatemelo sapere (nei commenti qui sotto oppure via twitter o facebook), così organizziamo per incontrarci. A sabato!

Aggiornamento del 24.10.2011: sono disponibili video e slides del mio intervento al KnowCamp 2011

Tempo libero a disposizione non ce n’era. A quarant’anni tra lavoro, famiglia e attività agonistica mi rimaneva solo la via del furto: rubare ore al sonno per dedicarmi allo studio di nuovi linguaggi e piattaforme. Prima è stato il turno di JavaScript, poi di Python, Django, Ruby e infine Node e MongoDB. Ora mi considero un programmatore poliglotta, capace di scrivere codice in una moltitudine di linguaggi.

Eppure in passato sono sempre stato convinto che fosse più produttivo concentrarsi su una sola piattaforma per conoscerla fino in fondo e sfruttarne al meglio le possibilità. Sulle ragioni che mi hanno indotto a prendere quella decisione potrei scrivere una decina di articoli, e magari lo farò prima o poi, ma quel che desidero condividere oggi sono le lezioni che questa esperienza mi ha insegnato.

A dire il vero ci ho già provato una volta, buttando giù appunti e abbozzando un articolo poi miseramente abbandonato. Per fortuna qualche giorno fa sono incappato in Advantages of Being a Polyglot Programmer, stupefacente articolo di Davy Brion. Il suo è precisamente il pezzo che io non riuscivo a scrivere, parola per parola. Davy elenca quelli che secondo lui sono i cinque principali vantaggi del programmatore poliglotta. Io ne aggiungo uno e ve li propongo – fate conto che sia io a parlare attraverso lui, o viceversa.

Quali sono i vantaggi del programmatore poliglotta?

Espandere i propri orizzonti

Nell’imparare un nuovo linguaggio c’è molto più che apprenderne la sintassi. Si scoprono nuove tecniche, nuove librerie e nuovi modi di affrontare e risolvere i problemi. Assorbiamo una conoscenza già diffusa nella comunità che si è raccolta attorno al linguaggio, e tuttavia nuova per noi. A seconda del nostro background può capitare di imparare tanto, oppure solo qualcosa qui e là. Se già conosciamo un linguaggio dinamico a oggetti, per esempio, impararne uno nuovo non aggiungerà granché al nostro bagaglio. Se al contrario conosciamo solo linguaggi statici, scoprirne uno dinamico sarà un’esperienza davvero arricchente. E’ proprio questa miscela di paradigmi e conoscenze nuove, grandi e piccole, che influenzerà in modo determinante il nostro modo di risolvere i problemi in futuro.

imparare più facilmente

La pratica rende perfetti. Dedicarsi con costanza all’apprendimento rende più semplice l’atto stesso di apprendere. Tanti hanno difficoltà ad accettare novità che sembrano in conflitto con quel che conoscono. Studiare un linguaggio che si basa su nuovi paradigmi (pensate alla programmazione funzionale) è difficoltoso perché ci costringe a ragionare al di fuori di strutture e regole che ci sono familiari. La seconda volta sarà già più facile, perché l’esperienza precedente ci avrà insegnato a non lasciarci condizionare da ciò che sappiamo. La terza volta sarà ancora più semplice, e così via. Tutti noi impariamo a imparare imparando.

rinnovare la passione per la programmazione

Quando ero programmatore C# / VB.NET mi capitava ogni tanto di non divertirmi più. In quei momenti scrivere codice era solo lavoro, non più gioia e tanto meno passione. Quei periodi potevano durare un paio di settimane, a volte un mese o due. Da quando mi sono dedicato a nuovi linguaggi non mi è più capitato di annoiarmi. Imparare di continuo cose nuove rende tutto più interessante, divertente e senz’altro impegnativo.

RIDurre la dipendenza dagli strumenti quotidiani e introdurne di nuovi

Fino a due anni fa non prendevo nemmeno in considerazione l’idea di scrivere codice senza usare qualche tipo di IDE. Ero dipendente da Visual Studio: IntelliSense, completamento automatico, navigazione, debugger integrato… tutte feature alle quali non credevo di poter rinunciare. Oggi preferisco scrivere codice in un semplice text editor per programmatori (nel mio caso Sublime Text 2), con una finestra terminale in cui lanciare i miei test. Fare a meno del debugger non solo è possibile, ma addirittura proficuo. Si procede a piccoli passi, facendo spesso test focalizzati che permettono di isolare e risolvere rapidamente i bug. Per motivi di lavoro ancora oggi uso e apprezzo Visual Studio ogni giorno, ma preferisco senz’altro lavorare in maniera spartana: text editor e terminale sono tutto quello che mi serve.

Lavorare così comporta una conseguenza importante. Si rende necessario (ri)diventare provetti nell’uso della finestra terminale, della linea di comando e, in alcune occasioni, addirittura di sistemi operativi diversi. Per imparare Ruby o Node spesso è meglio installare una distribuzione Linux (o lavorare su OS X se avete un Mac) piuttosto che tentare di far girare il tutto sotto Windows. In ogni caso conoscere la shell e i tool *NIX, specialmente di questi tempi, aggiungerà una freccia potente al nostro arco.

ridurre il legame col linguaggio prediletto

Coloro che lavorano esclusivamente con una piattaforma tendono a sviluppare con essa un vero e proprio legame emotivo. Lo so per certo perché è capitato anche a me (e diverse volte) nel corso degli anni. Se siamo legati emotivamente a un linguaggio ci diventa difficile rimanere equilibrati nel corso di una discussione, o restare calmi se percepiamo che il nostro prediletto è sotto minaccia (pensiamo a quel che sta succedendo a Silverlight proprio in queste ore). Praticando più linguaggi e piattaforme scopriamo che le nostre conoscenze e capacità sono trasferibili; che siamo programmatori a prescindere dagli strumenti che utilizziamo. Qualunque sia il destino della nostra piattaforma prediletta, noi non abbiamo nulla da temere.

migliorare e ampliare il network professionale

Studiare nuovi linguaggi e nuove piattaforme mi ha portato a conoscere molta più gente in due anni di quanta non ne abbia conosciuta nei venti precedenti. Quando si lavora a lungo nello stesso ambiente con gli stessi strumenti arriva il momento in cui non si ha (o non si sente) più bisogno di confrontarsi, informarsi e… imparare. Si acquisisce l’esperienza sufficiente a portare a casa il risultato, qualunque esso sia. Le stesse comunità di sviluppatori, per quanto ampie, tendono a chiudersi e diventare presto auto referenziali: stesse persone, stessi contributi, stesse domande e risposte. Aprirsi a comunità diverse illuminando la propria mente con idee che provengono dalle fonti più disparate è una esperienza esaltante. Soprattutto dopo anni di programmazione a testa bassa.

Una riduzione di questo articolo è stata oggetto di un mio Ignite (relazione lampo in cinque minuti) presentato il 8.10.2011 al KnowCamp 2011. Le slides e il video sono disponibili online.

Il cloud è robusto e affidabile. Il cloud risolve ogni problema di scalabilità. Nel cloud, anche la cacca profuma di rose. In teoria queste affermazioni sono corrette, ma occorre darci dentro per trasformarle in realtà. Specialmente quando c’è un database nel mezzo.

L’elaborazione collaborativa distribuita è diventata famosa grazie a progetti come SETI@home e Folding@home. Semplificando molto potremmo dire che questo tipo di applicazione prevede che un piccolo programma venga installato e fatto girare su decine di migliaia di computer volontari. La capacita elaborativa del progetto è data dalla somma delle elaborazioni individuali.

La novità di Chess@Home consiste nell’idea di ricorrere a codice JavaScript che gira nel browser, dunque senza alcuna necessità di client dedicati. Appositi widget presenti nelle pagine dei siti aderenti innestano l’elaborazione sul computer del visitatore, potenzialmente decuplicando il numero di nodi che partecipano all’elaborazione (più visitatori accedono alla stessa pagina contemporaneamente).

E’ facile intravedere complicazioni etiche ma occorre tenere conto del fatto che il progetto, messo in piedi in sole 48 ore, è nato soprattutto come esperimento per testare il limite delle tecnologie impiegate (Node.JS, MongoDB, JavaScript). Vi consiglio caldamente l’articolo di uno degli ideatori, Sylvain Zimmer, che descrive genesi e dettagli tecnici del progetto.

Già oggi potete giocare la vostra prima partita a scacchi contro la rete. Il mio cuore di nerd (che in anni ahimè troppo lontani ha fatto girare impunemente il client SETI per mesi e mesi) tifa per voi.

PS: domani al Romagna Camp 2011 terrò una relazione dal titolo “Quattro passi fra le nuvole (e non scordate il paracadute)”. Per saperne di più date una occhiata qui.

Codecademy è il modo più semplice per imparare a programmare. E’ interattivo, divertente, e lo puoi fare con gli amici

L’autore di Surviving (Google) Panda in Italia dipana per bene l’ingarbugliata sequenza di annunci e implementazioni culminate poi nel Panda Update. Non mancano alcuni consigli sensati (e tanto per cambiare originali) e una interessante conclusione che vi lascio leggere da soli. E bravo Stuart!

Sei un disegnatore, un fotografo, un artista o, più in generale, un creativo? Hai un sito che mai messo insieme con Dreamweaver grazie a quell’UNICA lezione scolastica di web design? Il sito non ce l’hai nemmeno, perché sono due anni che aspetti che tuo cugino lo faccia per te? Bè, noi siamo qui per aiutarti.

It is a collection of CSS and HTML conventions. It uses some of the latest browser techniques to provide you with stylish typography, forms, buttons, tables, grids, navigation and everything else you need in a super tiny (only 6k with gzip) resource.

A prima vista sembra molto ben fatto. Per tutte le informazioni e il download visitate la bella home page del progetto.

Si tratta per lo più di una versione di manutenzione che risolve numerosi problemi, primo fra tutti l’instabilità di Mono sull’ultima versione di MacOS X Lion.

L’importanza di questo aggiornamento va ben oltre le sue caratteristiche tecniche. Il titolo stesso dell’annuncio (And We Are Back) parla chiaro: si tratta di un segnale di continuità importante che Xamarin lancia alla comunità mondiale di sviluppatori Mono. Per informazioni sul progetto e sulle sue vicissitudini recenti vi invito a leggere l’articolo sul salvataggio di Mono che ho scritto qualche tempo fa.

Tra le tante chicche (alcune davvero gustose) vi segnalo a caso: concatenare due array senza crearne uno nuovo; mandare un testo in output su più righe; una funzione per eliminare un elemento da un array; una riga di codice che stampa lo stack delle chiamate correnti; un esempio di come trasformare gli argomenti di una funzione in array. Ce n’é per tutti i palati, dal principiante al più esperto, date una occhiata voi stessi.

Buona parte dei trucchi funziona con

la versione più recente del motore JavaScript (1.8) e non girano nella implementazione Microsoft del linguaggio (1.5), comunque per ogni snippet viene indicata la versione supportata. Non scordate di dare una occhiata ai commenti a fondo pagina per ulteriori suggerimenti e approfondimenti.

Buona esplorazione!

Oltre 200 i bug risolti e notevoli sono le novità introdotte, come per esempio il supporto per il refactoring. Consultate le release notes conoscere tutte le novità. Se volete saperne di più su questo interessante progetto vi invito a leggere Programmare in Python con Visual Studio 2010,  la recensione che ho scritto in occasione del lancio.

Aggiornamento del 2.8.2011: siamo arrivati alla RC2

La versione 2 di Google Web Fonts è appena stata rilasciata ed è ricca di novità. La nuova interfaccia consente di consultare rapidamente la directory di quasi 200 fonti tipografiche, inserendo quelle prescelte in una collezione personale. Gli esempi possono essere visualizzati come parole, frasi oppure interi paragrafi di testo. E’ anche possibile vedere tutti assieme i font della propria collezione, in una apposita pagina di prova.

I web font non sono una tecnologia nuova, sono stati introdotti dalle specifiche CSS3 (2002) e sono già molto diffusi. Quelli di Google sono forniti dinamicamente dalla Google Web Fonts API, una applicazione ad alte prestazioni ospitata sui server di Mountain View. Il lavoro che dobbiamo fare noi è semplicemente quello di incollare una riga di codice nella nostra pagina HTML, dopodiché potremo usare il web font come un qualunque font standard. Questa soluzione garantisce indipendenza dalla piattaforma software del client e libertà di scelta, al costo di un minimo rischio di incompatibilità verso browser molto datati (qui trovate una lista aggiornata).

Google tiene molto alla velocità della rete, e dei siti web in particolare, tanto da farne uno dei fattori di ranking per il suo motore di ricerca. Non stupisce quindi che venga fornito anche un indicatore di prestazioni che, in base al tipo e alle caratteristiche dei font selezionati, stima il tempo di caricamento del font nella nostra pagina web. In generale l’accesso alla API (e al sottostante CDN) è rapidissimo e non dovrebbe porre alcun tipo di problema.

Il mio interesse in Google Web Font v2 è nato in seguito alla visione della anteprima presentata alla Google I/O 2011. Se volete potete seguirla per intero anche voi:

Tutto comincia con una normale riunione tra programmatori, magari dedicata all’analisi di un nuovo intrigante progetto software. I toni inizialmente tranquilli all’improvviso si alzano e quello che doveva essere un incontro di routine si trasforma rapidamente in qualcos’altro. La discussione, ora vivace e concitata, diventa un vero e proprio alterco. Sedie penne e matite vengono spostate freneticamente, le voci si sovrappongono l’un l’altra e man mano che il tempo passa il meeting assomiglia sempre più a un furioso scontro tra galli combattenti. Se avete una certa carriera alle spalle ci siete già passati; se non l’avete state tranquilli, prima o poi ci passerete anche voi.

L’Ego del Programmatore

Quasi tutti i programmatori con cui ho avuto a che fare, incluso il sottoscritto, condividono almeno un tratto caratteriale: un ego ingombrante. Mike Bernat ci ricorda che diventare bravi programmatori è un processo lungo e impegnativo, che ci induce ad affinare le nostre capacità analitiche sviluppando mentalità e attitudine al perfezionismo. Alla fine del percorso ci troviamo in dote una forte fiducia nelle nostre capacità professionali, una fiducia che in alcune occasioni rischia di scatenare quello che io chiamo l’ego del programmatore, ovvero il nostro possente orgoglio.

Nel suo libro The Psychology of Computer Programming, Gerald M. Weinberg propone un’idea tanto semplice quanto difficile da mettere in pratica:

L’idea è che i programmatori devono combattere la loro naturale tendenza a considerare i loro programmi come parte di se stessi, un atteggiamento che comporta il rifiuto preconcetto di ogni tipo di critica. Piuttosto, dovrebbero fare del loro meglio per considerare le loro creazioni come oggetti indipendenti da se stessi, distaccati dal proprio io, e ascoltare le critiche in modo spassionato, giudicandole nel merito. E’ una vera e propria disciplina spirituale della quale nessuno di noi [programmatori] è dotato, ma vale la pena provarci.

Personalmente ricordo diverse occasioni in cui mio malgrado mi sono lasciato trascinare in “combattimenti tra galli”. A volte ne sono uscito vincente, altre volte ho dovuto ripiegare (non senza aver perduto qualche piuma). Col tempo credo e spero di essere migliorato, i consigli di Weinberg ho cercato e cerco tutt’ora di seguirli, ma certo la strada è lunga e tortuosa. E’ pur vero che in alcune occasioni l’aver ceduto, ritirando le mie proposte in favore di quelle altrui, si è rivelato un grave errore. Le conseguenze di certe scelte fatte in base a chi fosse il gallo più forte del pollaio, le pago ancora oggi. Ho imparato a mie spese che non sempre l’orgoglio del programmatore è un tratto negativo, anzi!

Se la vostra idea è quella giusta sostenetela a spada tratta fino in fondo, ma accertatevi che non sia esclusivamente il vostro orgoglio a condurre le trattative! In queste occasioni è molto importante concedere diritto di parola e giusta attenzione ai nostri interlocutori, soffermandoci a meditare sulle idee e le critiche ricevute prima di respingerle a priori. Se le riteniamo fondate facciamone tesoro apportando le dovute correzioni alla nostra stessa idea. Ciò che più conta, in realtà, è la qualità finale del progetto. Se alla fine si rivelerà un successo, il nostro orgoglio ne sarà ampiamente ripagato.

PS: a proposito di Weinberg, il suo libro è del 1971 ma è ancora attualissimo e ve lo consiglio caldamente. E’ disponibile in formato eBook su Amazon e altrove a prezzi modici. Non lasciatevi ingannare dal fatto che nel testo si parli di linguaggi ormai superati. In quarant’anni la gente non è cambiata affatto.

Fino a stamattina, quando un bell’articolo di Peter Knego mi ha svelato la scomoda verità (che inconsciamente rifiutavo di considerare). I programmatori oltre i trent’anni, per non dire dei quaranta, sono merce rara.

Partendo dai dati pubblici messi a disposizione da StackOverflow e relativi a un campione di ben 37.400 programmatori, Peter ha indagato sul rapporto tra età, reputazione e quantità di programmatori ancora attivi. Ne è uscita una serie di grafici davvero interessante.

Quantità di Programmatori per fasce di Età

La distribuzione per età (in blu nel grafico) è stata una bella sorpresa. E’ risaputo che col passare degli anni gran parte dei programmatori tende a cambiare carriera, di solito progredendo verso ruoli manageriali. E’ l’entità della riduzione che, almeno dal mio punto di vista, è stupefacente. Il picco si raggiunge a soli 27 anni, dopo di ché il numero dei programmatori si dimezza ogni 6 o 7 anni.

Età e Reputazione dei Programmatori

Osservate come nel grafico precedente la reputazione dei programmatori su Stack Overflow (in rosso) tenda ad aumentare con l’età. Si tratta quasi di una progressione lineare. L’andamento è meglio comprensibile se diamo una occhiata a quest’altro grafico:

I programmatori veterani pongono meno domande su Stack Overflow, ma rispondono molto più frequentemente dei loro colleghi più giovani. Un quarantenne risponde mediamente il doppio delle volte di un collega ventenne.

I veterani sono davvero più abili dei giovani?

A questo punto Peter si è posto una domanda intrigante: la qualità delle risposte migliora con l’età? I veterani forniscono le risposte migliori? Il meccanismo di premiazione delle domande e delle risposte utilizzato da StackOverflow ha permesso a Peter di elaborare l’andamento dei voti positivi ottenuti, suddivisi  per età :

Il grafico dimostra che la qualità media delle risposte non migliora significativamente in rapporto all’età dei programmatori. A quanto pare i veterani migliorano la loro reputazione soprattutto fornendo più risposte, piuttosto che migliorandone la qualità.

Riassumendo:

• Il numero di programmatori cala significativamente con l’età. L’apice è attorno ai 27 anni, poi si verifica un crollo costante.
• I programmatori quarantenni rispondono al doppio e pongono metà delle domande dei colleghi ventenni. I veterani insegnano e i giovani imparano, come dovrebbe essere.
• La qualità delle risposte non migliora significativamente col passare degli anni.
• I veterani migliorano la loro reputazione soprattutto perché sono molto più attivi dei loro giovani colleghi.

Ci sarebbe molto da dire a proposito di questi dati. Per esempio si potrebbe ipotizzare che i veterani abbiano semplicemente più tempo a loro disposizione per rispondere ai quesiti posti dai colleghi, ma quel che balza all’occhio qui è senz’altro il calo del numero di programmatori man mano che l’età avanza.

Per quanto mi riguarda, a 41 anni suonati, mi trovo già al di là del guado. La cosa è ancor più imbarazzante visto e considerato che non credo né mi aspetto di cambiare mestiere nei prossimi anni. E voi, miei cari lettori, a che punto del percorso vi trovate ora? Io ora spengo tutto e me ne vado in piscina a fare il ragazzino. Tiè.

Mentre tornavo in auto, riflettevo di quanta tristezza in questi anni ho visto transitare in molti uffici in cui aleggia quel senso di prigione, in cui le persone si sentono agli arresti domiciliari, mangiano solo con colleghi che odiano, con cui parlano di un lavoro o di un capo che altrettanto odiano, in cui la produttività e la creatività, apparentemente garantite dallo svolgersi in ambiente controllato e da orari stringenti, in realtà siano minime. Anzi, proprio quel sistema che in passato era stato creato per controllare il lavoratore, come se fosse un animale d’allevamento, ora è la causa dell’inefficienza e del disinteresse.

Nella intervista semi-seria che trovate qui sotto (mescolata a quelle degli amici) dichiaro che consiglierei senz’altro l’esperienza ai miei dipendenti. Confermo. I miei splendidi ragazzi lavorerebbero felicemente anche (forse soprattutto) sul cucuzzolo di una montagna, ma sulla efficacia del co-working ad ampio spettro qualche perplessità l’avrei.

Co-Working per tutti?

Le persone che odiano il lavoro e/o i loro colleghi, quelle a cui allude Gianluca nel corso del suo ragionamento, come reagirebbero immerse in un ambiente più ludico e ricreativo di quello abituale? Le tensioni si smorzerebbero e la produttività ne guadagnerebbe oppure, al contrario, approfitterebbero della situazione per rilassarsi fin troppo, cedendo alle inevitabili distrazioni? In fin dei conti l’esperimento Cowo on the Beach ha avuto successo anche e soprattutto, credo, perché i partecipanti sono tutte persone fortemente motivate, innamorate del proprio lavoro (e credetemi, a parte le battute ognuno di noi ha effettivamente lavorato nel corso della giornata!).

Ogni ambiente di lavoro è unico e distino, quindi non penso che esista una risposta assoluta, ma questa è una domanda che ogni datore di lavoro si porrebbe senz’altro. L’argomento mi sta particolarmente a cuore perché proprio in queste settimane stiamo valutando la possibilità di sperimentare in azienda metodi di lavoro alternativi a quelli tradizionali, come per esempio il telelavoro.

Sulla efficacia dei piccoli eventi

Nel suo articolo Gianluca accenna al fatto che il tempo incerto ha scoraggiato alcuni di quelli che si erano iscritti all’evento. E’ un peccato in effetti, anche perché la giornata tutto sommato è stata bella (abbiamo fatto anche il bagno!). A tavola mi dicevo però che non tutto il male vien per nuocere. Il gruppo ristretto ha consentito a tutti partecipare attivamente alla stessa discussione. Una tavolata di molte persone avrebbe portato alla creazione dei mini-conciliaboli tipici degli eventi di più ampio respiro, con conseguente frammentazione della discussione. E’ più facile che si creino intimità e senso di unità quando il gruppo è ridotto.

Con questo non voglio dire che sono contento delle assenze: si partecipa a un evento proprio per conoscere nuove persone interessanti. Senz’altro però la formula “cowobeach” è interessante anche perché  è diversa nei numeri. Non si tratta di uno dei soliti eventi che puntano alla partecipazione di massa.

Nota a margine per i geek che mi leggono

L’81% dei notebook impiegati al #cowobeach erano dei Mac Book. Io probabilmente rappresentavo il caso più singolare: in realtà scrivevo ed eseguivo codice sulla mia postazione Windows in ufficio, collegato dalla spiaggia via TeamViewer. Fa impressione constatare come in pochi anni l’adozione dei Mac da parte dei professionisti del settore sia aumentata.

Giornata di temporary coworking on the beach: ci troviamo la mattina al Boca Barranca, il wifi c’è ed è gratuito, la mattina si lavora, poi bagno in mare, pranzo, di nuovo lavoro e.. aperitivo! Un anticipo del RomagnaCamp che si terrà, sempre al Boca Barranca, dal 9 all’11 settembre

Alessandra ha appena pubblicato un aggiornamento con tanto di previsioni del tempo (non male dai) e suo programma di lavoro. Il mio è semplice: scrivere (poco) codice all’aria aperta e fare conoscenza con tanta bella gente.

Se decidete di venire, anche all’ultimo momento, iscrivetevi comunque! A domani!

You all saw a very small technology demo of Windows 8, and a brief press release. We’re all being quiet right now because we can’t comment on this. It’s not because we don’t care, aren’t listening, have given up, or are agreeing or disagreeing with you on something. All I can say for now is to please wait until September. If we say more before then, that will be great, but there are no promises (and I’m not aware of any plans) to say more right now. I’m very sorry that there’s nothing else to share at the moment. I know that answer is terrible, but it’s all that we can say right now. Seriously.

Quindi bocche cucite, almeno fino a Settembre. In seguito Brown interviene ancora, tirato per la giacchetta dai molti che hanno interpretato le sue parole nelle maniere più disparate:

This whole thing has blown way out of proportion. Base your information on our primary sources (like our press release), not on third party speculation. That’s not to minimize how everyone feels, but keep in mind that Windows 8 itself is still a ways off from retail, and even much further away from internal IT adoption. The 8 weeks until //build/ is a pretty small amount of time to wait in comparison.

Take some vacation time this summer, and look forward to the //build/ conference. Stop speculating based on just a small demo of some very cool new technology. Tell your management to do the same: if they’re basing your project work for the next X years on the results of a quick demo for an unreleased operating system, then they are doing you and your company a real disservice.

Windows 8 è ben lontano dall’essere pronto, e quel che si è visto nel filmato è solo la prima di una serie di anteprime. Inutile fare speculazioni basate su una demo di pochi minuti. Questa estate godetevi le vacanza, ne riparleremo al vostro ritorno. Dite ai vostri manager di fare lo stesso. Se stanno pianificando il lavoro dei prossimi anni basandosi solo su una breve anteprima di un sistema operativo non ancora pronto, allora stanno facendo un grave errore.

Non è mica la prima volta

Niente da obiettare da parte mia. Mi limito a rilevare che non è la prima volta che il futuro delle piattaforme Microsoft viene messo in discussione anche dallo stesso personale Microsoft. Leggendaria la gaffe di Bob Muglia, Vice President for Server and Tools Businesses (mica cotica) riportata fedelmente da Mary Jo Foley:

“Silverlight is our development platform for Windows Phone,” he said. Silverlight also has some “sweet spots” in media and line-of-business applications, he said.

But when it comes to touting Silverlight as Microsoft’s vehicle for delivering a cross-platform runtime, “our strategy has shifted,” Muglia told me.

Silverlight will continue to be a cross-platform solution, working on a variety of operating system/browser platforms, going forward, he said. “But HTML is the only true cross platform solution for everything, including (Apple’s) iOS platform,” Muglia said.

All’epoca fu necessario un comunicato congiunto di Steve Ballmer (CEO Microsoft) e del penitente Bob Muglia per acquietare la tempesta scatenata da queste parole. Sarà un caso che recentemente Muglia abbia annunciato il trasloco ad altri lidi?

Il fatto è che le tante aziende che hanno investito molto e – ahimé – esclusivamente sulle piattaforme Microsoft ora guardano con terrore a uno scenario, per quanto improbabile, che non veda Silverlight, WPF e .NET in cima all’agenda della casa madre.

Il futuro del Web è Silverlight?

Personalmente non ho dubbi sul fatto che il futuro delle piattaforme tecnologiche Microsoft sarà garantito. La domanda cruciale che ogni programmatore dovrebbe porsi è un’altra. Il futuro del web è Silverlight? In soldoni, su cosa vale la pena investire tempo, risorse e denaro? Temo la risposta non sia quella che i programmatori Silverlight vorrebbero sentire.

Migliaia di aziende, enti pubblici e organizzazioni non governative internazionali che oggi usano la API dovranno trovare soluzioni alternative, probabilmente a pagamento. Almeno gli è stato concesso un po’ di tempo: Google garantisce un periodo di tre anni prima della sospensione del servizio.

Questa notizia induce ancora una volta alcune riflessioni circa l’affidabilità del Cloud Computing, modello di sviluppo verso il quale, volenti o nolenti, tutti noi siamo diretti.

Stand-Alone Vs Cloud Computing

Le vecchie applicazioni stand alone funzionano sempre e comunque. Prima o poi il programmatore originale sparisce dalla circolazione; del codice sorgente (se disponibile) nessuno capisce più nulla, ma l’applicazione continua a girare. E se una delle librerie usate dall’applicazione (le vecchie .dll, per capirci) viene improvvisamente abbandonata dal produttore? Non ci sono problemi, l’installazione gira come prima.

Nel dorato mondo PaaS le applicazioni smettono di funzionare non appena una singola API remota diventa inaccessibile. Non mi sembra una differenza da poco.

Disservizi e sorprese

Si potrebbe obiettare che appoggiarsi a una API gratuita per sviluppare un prodotto strategico non è una mossa intelligente e che comunque casi di disservizi come questo sono assai rari. In Aprile alcuni server Amazon AWS (la piattaforma cloud più usata al mondo) sono andati in corto circuito lasciando improvvisamente a piedi centinaia di fornitori di servizi e diversi milioni di loro utenti. Il disservizio, durato oltre ventiquattro ore, è avvenuto nonostante AWS sia un servizio a pagamento di altissimo livello che garantisce un livello di Service Level Agreement (SLA) superiore al 99%.

Un caso diverso ma dalle stesse conseguenze  si è verificato proprio in casa Google poche settimane fa, quando Google App Engine è diventato a pagamento (almeno per alcuni livelli di utilizzo prima gratuiti), mettendo di fatto fuori mercato molti piccoli servizi gratuiti che avevano scelto la piattaforma cloud del gigante di Mountain View.

Le contromisure necessarie

Non per questo penso che il cloud computing vada evitato, ne sono anzi un sostenitore convinto, ma è importante per noi tutti comprendere a fondo i limiti e i rischi che questo nuovo paradigma porta con sé.

Un paio di anni fa ho scritto un programma di backup remoto che si appoggia a Simple Storage Service (S3), uno dei servizi della piattaforma Amazon AWS. Il programma ha continuato a lavorare impunemente mentre il disastro si abbatteva sui server Amazon della East Coast perché, fin dall’inizio, era progettato per far fronte a evenienze come questa. Usa server multipli ridondanti dislocati su più aree geografiche, in modo che il crash di una singola server farm non lo mandi in tilt. E’ bene aspettarsi il peggio dai servizi cloud per essere pronti a gestire la crisi se (quando) verrà.

Per quanto riguarda il modello di business, è necessario adottarne uno che garantisca margini sufficienti a compensare improvvisi aumenti delle tariffe, anche solo per il periodo necessario alla eventuale dislocazione. La tendenza generale del mercato è comunque rassicurante: in questi anni costi dei servizi cloud sono calati costantemente.

Le responsabilità stanno da entrambe le parti

E se domani mi si annunciasse che S3 è improvvisamente deprecato? Fortunatamente per me e per le migliaia di altri il servizio non è gratuito e assicura ad Amazon utili stellari, ma non è questo il punto. Il punto è che in ogni momento potrebbe succedere.

I fornitori di servizi cloud hanno una grande responsabilità: garantire la continuità del loro servizio anche e soprattutto nel lungo periodo. Speriamo che ne siano coscienti. Noi programmatori e analisti dobbiamo tenere conto dei rischi che corriamo quando scegliamo di lavorare su piattaforme cloud, progettando i nostri prodotti di conseguenza.

Aggiornamento. Venerdì 3 giugno Google ha ritoccato l’annuncio ufficiale. La chiusura è annullata e la Translate API verrà messa a pagamento.

La tentazione della scorciatoia. E’ difficile resisterle, prima o poi ci caschiamo tutti. In alcuni casi isolati vale la pena scegliere la strada più veloce, ma non è certo questa la via maestra. E’ pericolosa e in genere causa più problemi di quelli che risolve. Una scorciatoia può farti risparmiare qualche ora ma i danni causati possono costarti mesi di lavoro.

La fretta, cattiva consigliera, è addirittura diabolica quando applicata alla pratica che tutti noi programmatori odiamo di più: la soluzione di bug. Nella mia carriera ricordo distintamente le circostanze in cui, risolvendo frettolosamente bug, ho generato mostri.

Non fidatevi di voi stessi quando svolgete attività delicate o “risolvete” bug nel vostro codice o in quello degli altri. Assicuratevi che qualcuno verifichi quel che state facendo o, se non è possibile, fate in modo di testare e ritestare (possibilmente con l’aiuto di altri) quel che state combinando. Gli unit test sono i vostri migliori alleati. Se proprio dovete prendere una scorciatoia fate in modo che il vostro capo la avvalli (copritevi le spalle).

Nota a margine

Se avvertite un leggero formicolio alle punte delle dita mentre digitate codice fermatevi e meditate su quel che state facendo. Il vostro sesto senso di programmatore vi sta dicendo che c’è qualcosa che non va. E’ una capacità che si acquisisce col tempo e soprattutto con l’esperienza. Se non vi è ancora capitato fidatevi, prima o poi la svilupperete anche voi: è un potente alleato di ogni programmatore. Non scherzo! 😉

La superbia è un atteggiamento molto frequente tra noi programmatori. Io stesso sono – ahimé – un superbo seriale. Non importa quanto ci impegniamo. Ci saranno sempre colleghi che giudicheranno male il nostro codice, che penseranno di poter far meglio.

Non criminalizzare il codice degli altri. Prima o poi sarà il tuo a  finire sotto esame. La critica oggettiva va bene, i consigli e le osservazioni professionali pure, ma non esprimere giudizi. Sii umile. C’è sempre da imparare dal lavoro dei colleghi.

L’uom superbo si pone sopra gli altri, e crede che gli si debba ogni cosa; gli altri, per lo contrario, lo mettono nell’ultimo grado, né gli concedono nulla.

Confucio

Perché così poche Startup scelgono .NET Framework?

Guardando all’intero ecosistema delle Startup internet, è facile riscontrare che ben poche adottano il .NET Framework. Ci sono eccezioni importanti e significative, come per esempio Stack Overflow, ma le tecnologie dominanti sono altre: Ruby on Rails, PHP e Python su tutte. Ian Muir, Senior Developer di Piehead, in un suo interessante articolo tenta di individuare le ragioni che fanno di .NET Framework una scelta poco apprezzata dal vivace e  dinamico mondo delle Startup.

Il costo della piattaforma Microsoft

Se per le grandi aziende le voci di spesa davvero rilevanti sono stipendi, hardware, infrastrutture, banda e dati, per le nostre Startup il problema è innanzi tutto partire. Ruby on Rails, PHP, Python e i loro fratelli sono soluzioni FOSS (gratuite e open source) che permettono di lavorare a costo zero mentre l’ambiente .NET è al contrario un closed-source a pagamento.

Muir ricorda che già da qualche anno Microsoft ha lanciato il programma BizSpark che tra le altre cose elimina gran parte dei costi di adozione del .NET Framework. La differenza di spesa insomma non sarebbe così significativa. Peccato che BizSpark sia pressochè sconosciuto.

Ci sono soluzioni alternative. Showcase Lane per esempio è sviluppato interamente in ASP.NET MVC, ma gira sotto Mono. Se vi interessa questo approccio qui potete leggere tutti i dettagli in proposito.

Difficoltà nella applicazione della Metodologia Agile

Inutile negarlo, questi sono gli anni della metodologia agile. I giovani imprenditori rilasciano i loro prodotti il più velocemente possibile, spesso in versioni beta appena funzionanti, che implementano a malapena le funzionalità di base. Ruby, Python, PHP e soci dispongono di strumenti mirati per lo sviluppo e il deploy rapido delle applicazioni, qualcosa che in parte manca al mondo .NET. Nel suo articolo Muir sostiene che in realtà non c’è una gran differenza nei tempi di sviluppo.

Concordo con Muir anche se dimentica un dettaglio importante. Molti startupper sono programmatori alle prime armi, spesso ricchi di idee da lanciare rapidamente, ma poveri di capacità tecniche. E’ in questo scenario che linguaggi e tecnologie come Python e Ruby brillano di luce propria rispetto a un ambiente monolitico e piuttosto sofisticato come il .NET Framework. La curva di apprendimento vincente è quella dei linguaggi open source.

.NET è roba da Enterprise (e comunque Microsoft va boicottata)

Muir sostiene che le startup non usano .NET per motivi culturali più che tecnologici. Voce di popolo vorrebbe che Microsoft sia apprezzata dalle enterprise mentre PHP e Ruby sarebbero l’ideale per le piccole (e sfigate) startup. Questa percezione diffusa influenzerebbe i giovani imprenditori inducendoli ad adottare una piattaforma senza chiedersi quale sia lo strumento migliore per soddisfare le loro necessità.

Le cose stanno anche peggio di così. Specialmente nel mondo giovanile Microsoft è considerata il colosso pachidermico e monopolistico da boicottare in ogni modo. L’immagine non è il punto di forza di Microsoft.

Startup e Enterprise, mondi diversi

Gran parte delle startup incoraggiano i loro programmatori a imparare un ampio spettro di tecnologie piuttosto che specializzarsi su argomenti (linguaggi) singoli. Per le startup è la scelta giusta poiché dispongono di pochi programmatori e devono rimanere agili e pronte al cambiamento. Le grandi aziende al contrario hanno una cultura ingegneristica e sono organizzate in grandi team, nei quali ogni soggetto tende a essere molto specializzato. Sono differenze importanti che rendono difficile per un programmatore il passaggio da una realtà all’altra.

Ampliare la propria prospettiva

Secondo Muir quelli elencati sopra sono i fattori che più di altri condizionano la scelta della piattaforma da adottare. All’inizio della loro carriera i programmatori scelgono un percorso che in seguito diventa difficile cambiare. Il datore di lavoro dovrebbe impegnarsi in prima persona affinché i programmatori mantengano un attegiamento agnostico rispetto alle piattaforme tecnologiche, e siano sempre pronti ad abbracciare nuovi paradigmi e tecnologie.

Su questo punto Muir ha ragione da vendere. In tanti anni di lavoro ho provato sulla mia pelle quanto reale sia il rischio confinarsi nel proprio piccolo mondo. Impegnati nella soluzione dei problemi quotidiani scordiamo che è utile fermarsi ogni tanto e guardarsi intorno. Aggiornarsi su cosa avviene al di fuori del proprio ramo di expertise, consente di sviluppare una migliore visione d’insieme osservando le cose da una prospettiva più ampia.

Le persone contano più della piattaforma

Perché dunque le Startup non amano .NET Framework? Come abbiamo visto la risposta è tanto tecnica quanto culturale. Qualunque sia la tecnologia adottata, ciò che conta sono le persone che prendete a bordo. Se volete i migliori programmatori su piazza non selezionate specialisti PHP o .NET Framework. Cercate piuttosto persone con esperienze e conoscenze diverse, curiose, che abbiano voglia di imparare e siano pronte a rimettersi in gioco quando serve. Le persone giuste sono quelle capaci di prendere decisioni importanti senza lasciarsi condizionare (solo) dalle competenze già acquisite.

Post Scriptum. E se persone con queste caratteristiche non riuscite a trovarle o peggio, non potete permettervele? Non scendete a compromessi. Piuttosto, fate da soli.

L’annuncio ha gettato nel panico la comunità internazionale di sviluppatori Mono. Dal 2004, anno di nascita del progetto, migliaia di grandi e piccole software house hanno adottato la piattaforma per lo sviluppo rapido di soluzioni cross-platform. Purtroppo salvo rare eccezioni è frequente che progetti open source nati o assorbiti in grandi organizzazioni commerciali finiscano per essere abbandonati.

Xamarin al salvataggio di Mono

Fortunatamente non sembra essere questo il destino di Mono. Miguel de Icaza, il creatore di Mono, ha annunciato ieri la fondazione di Xamarin, startup indipendente interamente dedicata a Mono. Sembra di capire che gran parte del team originale stia confluendo nella nuova realtà, che per ovvie ragioni di copyright dovrà per prima cosa lanciare prodotti nuovi destinati a sostituire quelli a marchio Novell. Xamarin è al lavoro sull’allestimento di nuovi componenti .NET per iOS e Android e continuerà a garantire, supportare e sviluppare le piattaforme open source Mono e Moonlight.

La comunità di sviluppatori, incluso chi scrive, aveva accolto con un certo disappunto il lancio delle edizioni per iOS (MonoTouch) e Android (Mono for Android) della piattaforma. Si trattava infatti di versioni commerciali, anche piuttosto costose. Resta da vedere se e come Xamarin deciderà di riposizionare l’offerta di questi due importanti componenti. Ora che non c’è più una multinazionale dietro a Mono non mi sorprenderebbe affatto un ritocco verso il basso dei prezzi di listino.

L’uso effettivo di questa API sarà probabilmente circoscritto a una nicchia piuttosto ristretta, penso soprattutto alle agenzie di consulenza e SEO. Il messaggio utile da portare a casa (se ancora ce ne fosse bisogno) è che per Google le prestazioni dei siti e della rete in generale sono sempre più un fattore determinante, il rapidissimo sviluppo di Page Speed (prima le estensioni per browser, poi il servizio online e infine la API) ne è la prova più evidente.

In passato ho espresso alcune perplessità sulla reale applicabilità dei consigli forniti da questi strumenti, tuttavia rimango convinto della loro utilità generale. Proprio in questi giorni sto lavorando alla ottimizzazione del sito del nostro software gestionale e uso Page Speed per valutare i miglioramenti (o peggioramenti!) che riesco a ottenere. Finora ho raggiunto una valutazione di 80/100, partivo da 70 . Stimo di aver guadagnato 4-5 punti grazie ai consigli di Page Speed.

Per maggiori informazioni date una occhiata alla Guida per Sviluppatori e all’annuncio ufficiale sul Google Webmaster Blog.

Addentriamoci dunque nel mondo delle password e scopriamo come crearne di pratiche e sicure.

Come scoprire una password

Scoprire una password è davvero semplice. Esistono cinque metodi affidabili per raggiungere l’obiettivo:

1. Domandarla. E’ incredibile, ma il modo più usato per ottenere la password di qualcuno è domandargliela (spesso in cambio di qualcosa). Le persone dicono spesso la loro password a colleghi, amici e famigliari. In questo caso l’aver adottato password complicate non aiuta di certo.
2. Indovinarla. E’ il secondo metodo più usato per accedere a un account. E’ cosa nota che la maggior parte delle persone scelgono password facili da ricordare, e le più semplici sono proprio quelle che in qualche modo hanno a che fare con la persona obiettivo dell’attacco. Password come il vostro cognome, il nome di vostra moglie, il nome del gatto, la data di nascita sono molto frequenti. In questo caso l’unica, ovvia, soluzione è quella di scegliere password che non hanno relazione diretta con la persona.
3. Attacco a Forza Bruta. Molto semplice da realizzare. Un hacker tenta l’accesso usando password diverse volta per volta. Se la nostra password è “sun”, lui tenterà di entrare con “aaa, aab, aad … sul, sum, sun (TROVATA)“. L’unica cosa che blocca un attacco a forza bruta sono password di maggiore complessità e lunghezza (è proprio a causa di questo tipo di attacco che gli esperti IT le consigliano).
4. Attacco a Parole Comuni. Forma semplificata dell’attacco a forza bruta, nel quale l’hacker tenta di accedere ricorrendo a un elenco di parole molto usate. Invece di tentare combinazioni di lettere, l’hacker tenta di accedere con parole intere diverse di volta in volta, come per esempio “sum, summer, summit, sump, sun (TROVATA)“.
5. Attacco a Dizionario. Stesso principio dell’attacco a parole comuni, solo che questa volta l’hacker usa l’intero dizionario (ci sono circa 500.000 parole nella lingua inglese).

Quando la password è sicura?

Non puoi proteggerti contro attacchi del tipo “Domandarla” e “Indovinarla”, ma puoi proteggerti bene dalle altre forme di attacco. Un hacker di solito crea uno script automatico o un programma che svolge il lavoro al posto suo. Non ha alcuna intenzione di star seduto al computer tentando manualmente 500.000 parole per scoprire se una di quelle è la tua password.

Ne consegue che l’unità di misura della sicurezza diventa “quante password può tentare un programma per ogni unità di tempo (per esempio un secondo)?“. Il numero esatto non è determinabile, ma la maggior parte delle applicazioni non è in grado di gestire più di 100 accessi al secondo.

Ciò significa che per scoprire la password “sun” sono necessari:

• Forza bruta: 3 minuti
• Attacco a Parole Comuni: 3 minuti
• Attacco a Dizionario: 1 ora 20 minuti

Nota: ci sono 17.576 combinazioni di carattere possibili per “sun”. 3 lettere dell’alfabeto minuscolo = 26^3

__Quindi “sun” è una password davvero poco sicura, ma quanto tempo deve resistere una password affinché la si possa ritenere davvero sicura?

• una password che può essere scoperta in 1 minuto è fin troppo fragile
• 10 minuti – ancora troppo fragile
• 1 ora – non ancora abbastanza
• 1 giorno – cominciamo a ragionare. La probabilità che qualcuno lasci girare un programma per un giorno intero solo per accedere a un singolo account è modesta. Tuttavia non è impossibile.
• 1 mese – solo un hacker molto motivato ci proverebbe
• 1 anno – passiamo dal rischio reale al rischio teorico. La NASA o la CIA non potrebbero accettare un livello di sicurezza così basso. Il resto di noi, beh – non abbiamo il loro tipo di nemici e la nostra azienda non è certo così allettante.
• 10 anni – siamo ormai entrati nel campo della teoria pura
• Una vita: 100 anni – probabilmente questo è un limite accettabile per la maggior parte di noi. Chi si preoccuperebbe per una password che potrebbe resistere fin dopo la sua morte? E’ confortante pensare a una password che è “sicura per tutta la vita”

Analizziamo con attenzione il livello “100 anni”. Suona bene e ci fa sentire sicuri. C’è però la possibilità che un hacker sia particolarmente fortunato e trovi la password giusta dopo soli 15 anni di tentativi, invece di 100. Improbabile, ma può succedere.

Alziamo dunque la posta ancora una volta, puntando al massimo. Vogliamo una password che richieda 1.000 anni per essere scoperta– chiamiamolo livello “sicuro per sempre“. Dovrebbe essere abbastanza, no?

Creare password sicure e davvero utilizzabili

Ora che abbiamo coperto le basi diamo una occhiata a qualche esempio sul campo, cercando di capire quanto utilizzabile possiamo rendere una password pur mantenendola “sicura per sempre”.

Nota: gli esempi sottostanti sono tutti basati su una ipotesi di 100 tentativi di accesso al secondo. Viene riportato l’attacco più efficace per scardinare ogni password – forza bruta, parole comuni o attacco a dizionario.

Cominciamo dalla classica password di 6 caratteri

[table id=1 /]

In questo caso la complessità vince chiaramente. Usare una password con caratteri maiuscoli e minuscoli, numeri e simboli è molto sicuro. Usare una semplice parola come password è inutile.

Ciò significa forse che i colleghi dell’IT e i consulenti sulla sicurezza hanno ragione? No. Una password di 6 caratteri non funzionerà comunque. Nessuno è in grado di ricordare una password come “J4fS<2”, il che vuol dire che prima o poi verrà inevitabilmente trascritta su un post-it o altrove.

Se vogliamo password veramente utilizzabili dobbiamo approcciare il problema in modo diverso. Prima di tutto abbiamo bisogno di usare parole che possiamo ricordare, qualcosa di semplice che possiamo scrivere con facilità.

Come queste:

[table id=2 /]

Usare più di una parola per password aumenta significativamente il livello di sicurezza (da 3 minuti a 2 mesi). Tuttavia, usando 3 parole invece di 2 ci ritroviamo con una password estremamente sicura.

Sono necessari:

• 1.163.859 anni per scardinarla con un attacco a forza bruta
• 2.537 anni con un attacco a parole comuni
• 39.637.240 anni con un attacco a dizionario

E’ 10 volte più sicuro usare “this is fun” come password piuttosto che “J4fS<2”.

Se poi volete stare assurdamente al sicuro, scegliete parole poco usate per comporre la vostra password – qualcosa come:

[table id=4 /]

Una password sicura e al tempo stesso davvero utilizzabile non è una password complicata. E’ piuttosto una frase semplice composta da tre o più parole.

Non è solo questione di password

Una cosa è scegliere password sicure e utilizzabili. Un’altra è prevenire gli attacchi degli hacker. Si tratta di un obiettivo semplice da raggiungere. Per impedire che gli script automatici lavorino efficacemente è necessario:

1. Aggiungere una pausa tra i tentativi di accesso. 5 secondi tra un tentativo e l’altro sono sufficienti. E’ un lasso di tempo abbastanza breve perché non si noti (ci vogliono più di 5 secondi per rendersi conto di aver sbagliato la password e digitarne una nuova). Obbliga l’hacker a un solo tentativo ogni 5 secondi (invece che 100 tentativi al secondo).
2. Aggiungere una pausa di penalizzazione se qualcuno inserisce una password sbagliata più di – diciamo – 10 volte. Una penalità di 1 ora è sufficiente. Di nuovo, una azione di questo tipo disturba seriamente qualunque script o programma hacker.

Un hacker può scoprire la password “alpine fun” in solo due mesi se è in grado di attaccare il nostro server 100 volte al secondo. Tuttavia con la pausa di 5 secondi tra un tentativo e l’altro la stessa password può resistere all’attacco per 1.889 anni.

[table id=3 /]

Tieni a mente questi concetti la prossima volta che sei al lavoro su applicazioni web o stai discutendo di sicurezza delle password con i tuoi colleghi dell’IT. Le password possono essere allo stesso tempo sicure e facili da ricordare.

Attribuzione

Il progetto è stato presentato al PyCon 2011 dal Microsoft Technical Computing Group ed è davvero ben fatto. Per tutti gli approfondimenti vi rimando al mio articolo Programmare in Python con Visual Studio 2010.

Questa nuova release porta in dote una serie di bug fix che rendono più stabile il progetto e nessuna nuova feature. A questo punto la Release Candidate 1, programmata inizialmente per il mese di maggio, subirà probabilmente un leggero slittamento. Immagino che dovremo aspettare almeno il prossimo mese.

Flessibilità e qualità prima di tutto

Inuit.css è pronto all’uso, se siete di corsa e non avete esigenze particolari potete usarlo così com’è. Quando serve è facile adattarlo al nostro progetto, soprattutto grazie all’alta qualità del codice sorgente, commentato molto bene. E’ proprio la cura che l’autore ha dedicato alla documentazione l’elemento chiave che ci consente di intervenire rapidamente, eliminando le parti superflue o ritoccando il codice ove necessario.

Qui sopra vedete uno snippet tratto dal foglio di stile originale. Notate come l’autore si sia preoccupato di fornire indicazioni su come organizzare la gerarchia dei font. Ben fatto!

La potenza è nulla senza controllo

Difficilmente Inuit.css prende l’iniziativa, preferisce lasciarla al designer. Prendiamo gli elementi base di HTML5 e CSS3. Inuit.css li supporta ma li isola in classi dedicate che useremo all’occorrenza.

La scelta del basso profilo è apprezzabile. Lascia il controllo nelle nostre mani, ma corre il rischio che – soprattutto al primo impatto – il framework sembri meno ricco rispetto ad altre soluzioni. In effetti non è sulla ricchezza che punta Inuit ma su flessibilità, estensibilità e… mobilità.

Tablet, smartphone e non solo

Il supporto per l’attributo @media consente a Inuit di ridefinire dinamicamente gran parte delle impostazioni in base al dispositivo (tablet, smartphone, stampante) che consuma la pagina. Il Grid System adottato deriva dal capostipite 960 Grid System (vedi in proposito l’articolo precedente), supporta matrici (grid) a 12 e 16 colonne e implementa un ingegnoso marchingegno che evita l’inserimento della classica class=end nell’ultima colonna.

A differenza della Tiny Fluid Grid vista la volta scrosa, Inuit è un Framework vero e proprio e supporta ben più della sola Grid. Sono presenti impostazioni predefinite e ben fatte per tutti gli elementi più comuni di una pagina HTML: header, paragrafi, liste numerate e non, tabelle, form, citazioni, link, immagini. Non manca una implementazione del Eric Meyer CSS Reset e il supporto per la modalità debug che rende visibile la grid sullo sfondo. Una occhiata alla pagina demo e soprattutto al suo sorgente è sufficiente per rendersi conto di quanti sono gli stili che Inuit.css ci mette a disposizione.

Giovani di belle speranze

Inuit è il nuovo arrivato, ha solo una ventina di giorni ed è in revisione continua. E’ giovane come il suo autore, il ventenne Harry Roberts (l’età non tragga in inganno, Harry è la mente che si cela dietro CSS Wizardry). Come tutti i giovani di belle speranze Inuit guarda al futuro e se ne frega allegramente del passato: supporta Internet Explorer a partire dalla versione 7 (update del 24.5: la release 1.5 introduce un supporto base per le grid in IE6).

Dovrà sgomitare un bel pò per conquistarsi uno spazio in una nicchia già affollata da una concorrenza agguerrita. Ha tutte le carte in regola per sfondare, prova ne è il fatto che a pochi giorni dal lancio qualche sito qui e là ha già cominciato ad adottarlo.

Se scegliete di usare Inuit nei vostri progetti fatemelo sapere. Chissà, potrebbero finire dritti dritti nella Web Gallery del sito ufficiale.

Dato per imminente a febbraio, del nuovo canale e-commerce di Google non si erano più avute notizie, tanto che qualcuno cominciava a domandarsi che fine avesse fatto.

Per informazioni approfondite vi rimando all’articolo che scrissi a suo tempo, qui mi limito a segnalarvi il link per creare un account, registrare i prodotti e impostare il proprio negozio su Google Shopping.

Il Grid Design e l’era dei CSS Framework

L’avvento dei CSS Framework si deve (principalmente) alla necessità di soddisfare l’esigenza di fluidità. Il capostipite, se non in ordine cronologico senz’altro per l’influenza che ha avuto, è il 960 Grid System. Altri prodotti famosi, per citarne solo un paio, sono Blueprint e Emastic. Questi framework hanno in comune l’obiettivo di velocizzare creazione, gestione e manutenzione dei fogli di stile ma se andiamo al nocciolo della questione ci accorgiamo che tutti si basano sul concetto chiave di Grid Design:

Una griglia tipografica è una struttura bidimensionale composta da una serie di guide verticali e orizzontali intersecanti (matrice) usata per organizzare il contenuto della pagina. La griglia offre una traccia sulla quale il designer può organizzare testo e immagini in maniera ordinata e razionale (Wikipedia)

Niente di nuovo, i tipografi hanno usato questa tecnica per secoli. Il Grid Design in declinazione web è fluido: le colonne (e gli spazi tra le colonne) che compongono la matrice sono capaci di adattarsi alla risoluzione dell schermo.

Gran parte dei CSS Framework non si limitano a implementare versioni più o meno sofisticate del Grid System ma offrono una serie di servizi aggiuntivi nel tentativo di risparmiare al designer i compiti più ripetitivi e tediosi. Non sempre ci riescono. Ogni sito ha esigenze specifiche e ogni designer abitudini consolidate. E’ difficile che una soluzione standard sia l’ideale per ogni esigenza. Spesso preferisco la via di mezzo: strumenti agili che consentono di portare a casa rapidamente il risultato senza aggiungere (molto) più del necessario.

In questa mini-serie di tre articoli prenderò in esame tre diverse soluzioni che implementano il Grid Design e che ci permettono di implementare, con diversi gradi di complessità (e numero di funzionalità), pagine web fluide.

Tiny Fluid Grid

Se non altro amerete questa soluzione a causa del suo design: il sito è oggettivamente splendido. E facile da usare. In effetti Tiny Fluid Grid non è un CSS Framework vero e proprio ma una semplice soluzione interattiva che vi consente, agendo su tre semplici regolazioni (numero di colonne, spazio tra le colonne e larghezza dell’area client), di configurare online la vostra CSS grid. Il pulsante Preview offre una anteprima (anch’essa interattiva) della grid. L’unica altra opzione disponibile è il Download. Otterrete un archivio compresso che contiene due files: il foglio di stile grid.css e un index.html che contiene un esempio d’uso della grid appena creata:

Una occhiata al foglio di stile ci consente di capire la struttura della grid

Una classe per ogni larghezza di colonna. Poiché larghezza e margini delle colonne sono espressi in percentuale la nostra grid si adatta alla risoluzione dello schermo, con i limiti imposti dagli attributi min-width e max-width. L’implementazione lato HTML è banale (tralascio le parti non rilevanti):

La nostra grid è contenuta in un div di classe “container”. Le colonne sono a loro volta dei div. Per ottenere più colonne nella stessa riga dobbiamo assicurarci che la somma dei numeri contenuti nel nome di ogni classe (grid_x) sia uguale al numero di colonne di cui è composta la grid. Nel nostro caso la seconda riga è composta da tre div grid_4 (4×3=12); la terza riga da due colonne: grid_3 e grid_9 (3+9=12). Semplice no? Naturalmente possiamo ritoccare il foglio di stile come vogliamo, adattandolo alle nostre esigenze.

Nel prossimo articolo della serie affronteremo un CSS Framework vero e proprio, anche questo snello e semplice da usare. Se ancora non l’avete fatto abbonatevi al feed RSS per non perdere la prossima puntata, oppure iscrivetevi alla mailing list (riquadro in alto a destra). Mi raccomando!

Può capitare che questo comportamento non sia quello desiderato. Oggi al lavoro ho implementato una funzionalità interessante: il download della versione PDF di una pagina web. Il pdf viene costruito dinamicamente nel momento stesso in cui il visitatore clicca un link. Questo accorgimento libera il webmaster dalla tediosa (e facilmente dimenticabile) necessità di rigenerare il pdf ad ogni minimo ritocco della pagina.

Volevo che cliccando sul link si avviasse automaticamente il download, così da ‘costringere’ l’utente a interagire col PDF in un secondo tempo rispetto all’esperienza di navigazione. Se scarichi un PDF è per stamparlo o consultarlo con calma o magari passarlo a un collega, no?

Costringere l’utente a usare il menu contestuale del browser (Salva link con nome..) non è certo la scelta ideale dal punto di vista dell’esperienza utente, tanto più che in questo caso il link non è statico e invoca codice JavaScript. Per ottenere il risultato desiderato dobbiamo inviare direttamente il file all’utente. [cci_asp theme=”standard”]Response.TransmitFile()[/cci_asp] è il metodo che invia il file dall’applicazione ASP.NET al client, ma prima dobbiamo preoccuparci di aggiungere un paio di header al nostro messaggio di output:

E’ importante fornire il ContentType corretto altrimenti il browser non sarà sempre in grado di gestire i contenuti del file. Internet Explorer per esempio offre l’opzione di aprire direttamente il file (verrà scaricato nella cache). Nel nostro caso se l’utente sceglie l’apertura diretta IE lancerà Acrobat Reader perché ContentType è application/pdf.

Altro accorgimento è la chiamata al metodo Path.GetFileName() in riga 7. Non sarebbe necessario se non fosse che taluni broswer arcaici e superati (ogni riferimento a IE è naturalmente voluto) non sono in grado di gestire intelligentemente il filename e, quando propongono il nome del file da salvare, riproducono l’intero path del file sul server. Questo comportamento tra l’altro è pericoloso perché espone l’intera struttura  del sito, dalla radice al folder che contiene la pagina, al visitatore.

Se la routine deve essere usata in un modulo e non direttamente in una pagina aspx ricordate di sostituire Response con HttpContect.Current.Response. Buon lavoro!

Come è possibile tutto ciò? Gran parte del merito va attribuito al metodo produttivo adottato da DISQUS: metodologia agile, hardware in affitto e facilmente scalabile, grande fiducia nella capacità dei propri talenti: ognuno degli otto ingegneri è anche product manager. Secondo DISQUS tutto questo è stato possibile anche e soprattutto grazie a una scelta che si è rivelata determinante: l’adozione del linguaggio Python e del web framework Django.

Il video della conferenza

Fortunatamente gran parte dei contenuti di PyCon 2011 sono disponibili al pubblico sotto forma di registrazioni audio-video e di slideshow. In questo filmato possiamo seguire Jason Yan e David Cramer (due dei super-otto, quanto sono giovani!) nel corso della loro conferenza.

Le slides

Se non avete tempo (o voglia) per seguire l’intera lezione potete sempre dare una occhiata a queste slides che spiegano in maniera concisa il processo di sviluppo e deployment e, soprattutto, pregi e difetti del lavoro con Python. Curioso come molti di loro abbiano cominciato da Django prima ancora di imparare Python! E’ un po’ la dimostrazione che prima viene il talento, poi il know-how.

Una questione di metodo

Da molti Python è considerato un linguaggio inadatto a gestire siti con grande traffico o applicazioni molto impegnative sotto il profilo delle prestazioni. L’esperienza DISQUS dimostra platealmente il contrario. In un prossimo articolo mi riprometto di approfondire la questione Python/Prestazioni. Se qualcuno vuol dire la sua in proposito è il benvenuto (sia sotto forma di commento che di guest post eventualmente).

Fondata da alcuni degli startupper più affermati e frequentata da quasi 2.000 utenti, molti dei quali attivamente coinvolti in progetti di startup, ISS è il posto ideale per chiedere consigli, proporre e discutere idee, cercare collaborazioni e chissà, trovare finanziamenti per i vostri progetti.

Italian Startup Scene è organizzata come Gruppo Facebook – in effetti si tratta dell’unica risorsa Facebook che frequento assiduamente. La lettura del gruppo è libera ma dovete iscrivervi per partecipare alle discussioni che sono molte, interessanti e pertinenti – astenersi perditempo! In queste settimane stanno nascendo i sotto gruppi regionali che servono ad agevolare conoscenze e scambi di informazioni tra gli utenti che vivono vicini.

Lavorare per una Startup italiana

Ma il progetto ISS di cui voglio parlarvi, anche perché è nato un po’ in sordina e credo meriti maggiore attenzione, è Jobs for Geeks. Si tratta di una bella bacheca interattiva dove le startup italiane propongono impieghi di ogni genere: programmatori, designer, esperti commerciali, managers e testers. A sottolineare lo spirito originale di ISS è presente anche il panel per la ricerca di soci fondatori. Nel momento in cui scrivo il panel Programmatori conta 9 posizioni disponibili.

Trattandosi quasi sempre di startup che operano nel campo delle tecnologie e della rete è facile trovare disponibilità per ogni tipo di collaborazione: part-time, freelance, remote. Non si tratta di offerte di lavoro canoniche neanche dal punto di vista della retribuzione. In tipico stile startup c’è chi cerca, per esempio, un .NET Developer che partecipi a un progetto senz’altro interessante ma attenzione, “Niente retribuzione, per ora, tanto affetto e tanta simpatia :)”

Niente male davvero.

Reddit ha conquistato un pubblico particolarmente ostico ed esigente grazie alla sua caratteristica più peculiare: essere un sistema aperto. Potremmo definire Reddit una semplice infrastruttura lasciata in gestione agli utenti, i quali ricambiano dedicandosi con dedizione alla cura dei contenuti. Su Reddit chiunque in pochi secondi può creare un’area nuova dedicata a un argomento non ancora trattato. Se il tema è valido i contributi arrivano: segnalazioni di nuove risorse (articoli, tutorial, opinioni), votazioni e discussioni spesso vivaci. Reddit è un po’ Wikipedia, un po’ Facebook e un po’ Twitter.

La scommessa è quella di una selezione naturale dei contenuti, compiuta dai loro diretti destinatari e non (solo) dagli autori, come succede nel caso degli aggregatori di notizie.

Reddit in Italia

In Italia Reddit è ancora poco conosciuto, ma qualcosa sta cambiando.

Il reddit

/r/italy propone solo contenuti italiani e al momento in cui scrivo sta per toccare i 1.000 lettori. Stanno nascendo altri reddit italiani, alcuni davvero curiosi e uno molto interessante.

Il reddit dei programmatori italiani

Il mio personale contributo alla diffusione di Reddit nel nostro paese è /r/programmazione. Platealmente ispirato alla controparte inglese, Programmazione è nato inizialmente come tentativo di rispondere a una mia esigenza personale: raccogliere in modo organizzato le migliori risorse italiane su programmazione, web design, posizionamento siti web (SEO) e dintorni. Articoli, tutorial, riflessioni, approfondimenti e notizie, purché pertinenti, sono tutti benvenuti. Partecipare è facile e poco impegnativo. Votate i contenuti più (o meno) interessanti e, se volete, segnalate i vostri link preferiti.

Se riusciremo ad attirare un pubblico abbastanza numeroso potremmo contribuire, nel tempo, alla creazione di una risorsa interessante per la comunità italiana.

Se per trovare ispirazione amate curiosare nel lavoro degli altri questo è proprio l’oggettino che fa per voi. Se siete programmatori continuerete a usare Firebug ****o Webkit Inspector ma questo strumento è talmente comodo che potreste decidere di aggiungerlo comunque ai vostri strumenti preferiti.

Come usare watermark.js

La libreria innesta il marchio nelle immagini marcate con la classe CSS “watermark”. Se il nome della classe non piace è possibile cambiarlo. Se il nostro watermark è in formato JPG la libreria aggiunge per noi un livello di trasparenza, altrimenti possiamo fornirle i più idonei formati PNG e GIF.

Prima di tutto inseriamo il riferimento allo script. E’ consigliabile inserirlo in fondo alla pagina, subito prima della chiusura del tag

body

Al caricamento della pagina chiamamo il metodo wmark.init

La variabile load agisce come un flag e serve a evitare che il codice venga eseguito ad ogni postback. Infine aggiorniamo i tag HTML delle immagini a cui vogliamo aggiungere il nostro watermark

E questo è tutto.

Sul sito ufficiale sono disponibili un paio di demo funzionanti. La seconda mostra un uso senz’altro originale della libreria: l’inserimento di Codici QR nelle immagini. Trattandosi di un progetto open source è possibile scaricare anche il codice sorgente di watermark.js.

Non tutto è oro quel che luccica

Essendo implementata lato client, la protezione delle immagini non è certo garantita al cento per cento. Dobbiamo decidere cosa è più importante, l’inviolabilità delle nostre immagini o la comodità di non doverle ritoccare prima di inviarle al server. Altro fattore da non trascurare è il calo di prestazioni. Il codice JavaScript deve caricare il watermark e inserirlo nell’immagine originale. Il tempo di caricamento potrebbe risentirne, soprattutto nel caso di pagine ricche di immagini.

Watermark.js è un progetto interessante e ingegnoso che va usato tenendo ben presente i suoi pregi e tutte le possibili controindicazioni.

In questi giorni ho avuto modo di testare Page Speed per Chrome su un certo numero di siti, sia sviluppati da me che da altri. Mi sono reso conto che non sempre i consigli, pur validi, sono facilmente applicabili. Molte inefficienze non sono sotto il nostro controllo perché i contenuti sono forniti da terze parti – annunci pubblicitari, pulsanti, widgets e così via. La stessa Google ha ottimizzato le prestazioni di AdSense solo recentemente, prima non era certo un fulmine di guerra.

Altri suggerimenti sono alla nostra portata ma quando ci mettiamo al lavoro ci rendiamo conto che rischiamo di impiegare un mucchio di tempo per ottenere miglioramenti appena percettibili. Un esempio? Il consiglio di combinare le diverse immagini di una pagina in un singolo sprite CSS. E’ abbastanza veloce raccogliere in un file tutte le immagini ma quando ci mettiamo a cambiare il codice HTML, CSS e JavaScript per caricare le porzioni dello sprite nei posti giusti ecco che il tempo necessario a portare a termine (e testare) il lavoro si dilata inesorabilmente.

Finché si lavora su pagine semplici i consigli di servizi come Page Speed (una menzione d’onore la merita YSlow) sono rapidi da implementare. Quando si tratta di ottimizzare siti complessi le cose si fanno più complicate. Il problema è che non c’è modo di predire con precisione quanto miglioreranno le prestazioni. Riprendendo l’esempio delle immagini, Page Speed fornisce una stima dei Kb che risparmierei creando un unico sprite CSS ma non può dirmi quanto tempo risparmierà l’utente che visitera il sito. Otterrò un miglioramento effettivamente percepibile?

Cum grano salis

L’esperienza ci aiuterà a scegliere quali ottimizzazioni implementare e quali tralasciare. Se fin dall’inizio avremo fatto bene il nostro lavoro non rimarrà molto da migliorare. Se  al contrario ci ritroveremo con decine di consigli di ottimizzazione beh, vorrà dire che la prossima volta dovremo lavorare meglio. In ogni caso usiamo questi strumenti con saggezza non lasciandoci prendere ciecamente dal “demone ottimizzatore”.

Avete mai notato che di notte, in una stanza poco illuminata, le persone che lavorano al computer sembrano circondate da un inquietante alone blu? Gli schermi per computer garantiscono una buona visione diurna vincendo la luce solare con colori brillanti e freddi (a dominante blu). Di notte, col buio o poca luce, tutto ciò affatica la vista. Mai capitato di alzarvi presto per scrivere codice o finire un articolo e dopo pochi minuti di lavoro ritrovarvi con gli occhi arrossati e irritati?

Flux usa la vostra posizione geografica e l’orologio del computer per determinare le condizioni di luce in cui vi trovate, adattando di conseguenza i colori dello schermo. La prima esperienza con Flux può essere disarmante. Cala la notte e rimanete (molto) perplessi dall’aggiustamento che avviene. Concedete a cervello e occhi il tempo necessario ad abituarsi, dopo qualche minuto non ci farete più caso. Dopo un’ora provate a disattivare Flux usando l’opzione Disable for an hour e… godetevi la cottura rapida della vostra retina. Un esperimento doloroso che non vorrete più ripetere.

Qualche consiglio

Flux determina la posizione geografica automaticamente, oppure potete impostarla a mano se (come capita al sottoscritto) il vostro provider vi colloca a 200km di distanza dalla posizione reale. Vi consiglio di impostare  una transizione oraria (slow), che renderà più graduale il passaggio dalle condizioni diurne a quelle notturne. In base ai vostri gusti e alle condizioni di luce in cui operate potete scegliere tra quattro colorazioni notturne: Tungsten, Halogen, Fluorescent, Daylight. Io mi trovo bene con Fluorescent ma vi consiglio di provarle tutte. Abilitate l’opzione per lanciare Flux all’avvio del sistema operativo, così diventerà parte integrante delle vostre abitudini. I vostri occhi vi ringrazieranno.

Per molti ma non per tutti

Se vi dedicate alla grafica Flux probabilmente non fa per voi, la resa dei colori non è il suo punto di forza. Flux è perfetta per chi scrive e naviga di notte. Sul sito ufficiale sostengono che l’ottimizzazione notturna dei colori concilia il ritmo sonno-veglia. Non so se sia vero ma so per certo che da quando ho installato Flux, una settimana fa, non riesco più a lavorare di notte se questa utility non è attivata. Se la provate fatemi sapere cosa ne pensate!

Come è potuto succedere?

In fatto di localizzazione una pagina ASP.NET non è diversa da una normale applicazione WinForms. In assenza di indicazioni diverse il .NET Framework rappresenta le valute in base alle impostazioni internazionali del computer che lo ospita. Durante sviluppo e collaudo non abbiamo avuto problemi perché lavoravamo su server aziendali locali. Tuttavia il server di produzione è americano, ed è così che pubblicando il sito ci siamo regalati un bel cambiamento di valuta, il tutto senza toccare una linea di codice.

Restituisce €1.567,50 in Italia e $1,567.50 negli Stati Uniti. Probabilmente a questo punto vi starete dicendo due cose:

1. Ma perché hai pubblicato un sito in italiano, per un pubblico italiano, negli Stati Uniti?
2. Te lo dovevi aspettare, cosa volevi che succedesse? Qualunque sviluppatore con un minimo di esperienza sa queste cose.

A proposito del primo punto ci sarebbe da scrivere un articolo intero (e magari lo farò). Basti sapere per ora che, malgrado le apparenze, ci sono (anche) buone ragioni per pubblicare siti italiani all’estero. Sul secondo punto naturalmente avreste ragione. Il fatto è che, nel grande schema delle cose, sono proprio i piccoli dettagli quelli che possono sfuggire. Per fortuna porre rimedio è stato semplice e indolore. Vediamo.

E’ tutta questione di Culture

In ogni pagina ASP.NET è possibile impostare il valore delle proprietà Culture e UICulture. Culture determina l’output delle funzioni influenzate dalla cultura: date, numeri, valute, orari. UICulture istruisce la pagina su quali risorse culturali caricare.

Impostare Culture e UICulture per tutto il sito

Intervenendo direttamente nel file Web.Config possiamo dire a ASP.NET quale è la cultura da usare in tutto il sito. In questo modo non dovremo preoccuparci di intervenire su ogni in pagina.

Attenzione alle maiuscole. uiCulture va bene; uiculture non va bene. Non sprecate mezz’ora per una sciocchezza del genere, l’ho già fatto io per voi.

Impostare Culture e UICulture per una pagina

Per modificare Culture e UICulture di una singola pagina è necessario impostare i corrispondenti attributi della direttiva @ Page

Questa tecnica può naturalmente venire usata in abbinamento alla precedente anche se devo dire che non mi viene in mente un motivo, uno scenario valido in cui ciò potrebbe essere utile.

Adattare l’output alla lingua del browser

Per adattare la cultura al linguaggio del browser che visita la pagina basta impostare UICulture e Culture su auto (non l’ho testato personalmente). E’ anche possibile cambiare la cultura dinamicamente via codice. Se volete sapere come fare consultate la documentazione ufficiale.

Dimenticavo…

C’è un’altra cosuccia che non ha funzionato perfettamente al momento del debutto. Immaginate la sorpresa del cliente che, ordinando un prodotto da €499 + IVA, si è visto proporre l’addebito su carta di credito per €1 (uno) IVA inclusa. Ma questa è un’altra storia…

Installazione

Trattandosi di una estensione sperimentale l’installazione è più laboriosa del solito. Nella barra degli indirizzi digitate about:flags e premete invio. Abilitate l’opzione API sperimentali di estensione quindi scorrete fino in fondo alla pagina e cliccate sul pulsante Riavvia adesso. Dopo il riavvio sarà finalmente possibile scaricare l’estensione e completare l’installazione. Per attivare Page Speed andate sulla pagina web che volete collaudare e aprite gli Strumenti per sviluppatori. Per maggiori informazioni consultate la pagina ufficiale dell’estensione.

Perché la velocità del tuo sito è importante

I siti veloci migliorano l’esperienza dell’utente e questo piace molto ai motori di ricerca, che già oggi misurano le prestazioni di ogni sito indicizzato. I risultati di queste misurazioni sono uno degli indicatori usati per determinare l’importanza dei siti web e quindi la loro posizione nei risultati delle SERP. Il fatto che Google stessa sia impegnata a fornire strumenti avanzati di ottimizzazione e misurazione la dice lunga su quanto questo indicatore sarà sempre più determinante nel prossimo futuro.

Se non siete convinti considerate questo: solo qualche giorno fa anche Yahoo a rilasciato la versione per Chrome di YSlow, la sua sua estensione per la ottimizzazione delle pagine web. Se due indizi non fanno una prova, poco ci manca.

Per un approfondimento dai una occhiata a Il futuro del codice sorgente è online?, la panoramica sul Progetto Orion e sulle IDE Online che ho pubblicato qualche tempo fa.

Mi ha colpito l’interfaccia, davvero al servizio dei contenuti. La Minimap è una trovata originale che offre una vista “da diecimila metri di quota” sul codice. Immaginate di levarvi in volo e osservare il vostro codice dall’alto: apparirà come una ‘lenzuolata’ sulla quale potete cliccare per spostarvi rapidamente da una zona all’altra del vostro documento. Notevole anche il doppio (o triplo) pannello che consente di lavorare in linea su più files.

      <p class="wp-caption-text">
        Doppio pannello per lavorare su più files contemporaneamente
      </p>
    </div></td> 
    
    <td>
      <p>
        <div id="attachment_1639" style="width: 220px" class="wp-caption alignnone">
          <a href="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png" rel="lightbox[1637]"><img class="size-full wp-image-1639 " title="SublimeText 2- Syntax Highlighting" src="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png?w=210" alt="SublimeText 2- Syntax Highlighting" srcset="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png?w=900 900w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png?resize=150%2C93 150w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png?resize=300%2C187 300w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-SyntaxHighlighting.png?resize=480%2C300 480w" sizes="(max-width: 525px) 100vw, 525px" data-recalc-dims="1" /></a>
          
          <p class="wp-caption-text">
            Syntax Highlighting di PHP, HTML e JavaScript nella stessa finestra
          </p>
        </div></td> </tr> 
        
        <tr>
          <td>
            <p>
              <div id="attachment_1642" style="width: 220px" class="wp-caption alignnone">
                <a href="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png" rel="lightbox[1637]"><img class="size-full wp-image-1642 " title="SublimeText 2 - RegEx" src="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png?w=210" alt="SublimeText 2 - RegEx" srcset="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png?w=900 900w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png?resize=150%2C93 150w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png?resize=300%2C187 300w, http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-RegEx.png?resize=480%2C300 480w" sizes="(max-width: 525px) 100vw, 525px" data-recalc-dims="1" /></a>
                
                <p class="wp-caption-text">
                  Ricerca e sostituzione con le Regular Expression
                </p>
              </div></td> 
              
              <td>
                <p>
                  <div id="attachment_1643" style="width: 220px" class="wp-caption alignnone">
                    <a href="images/SublimeText2-MultipleSelections.png" rel="lightbox[1637]"><img class="size-full wp-image-1643   " title="SublimeText 2 - Selezione Multipla" src="http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-MultipleSelections.png?fit=210%2C131" alt="SublimeText 2 - Selezione Multipla" srcset="http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-MultipleSelections.png?w=900 900w, http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-MultipleSelections.png?resize=150%2C93 150w, http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-MultipleSelections.png?resize=300%2C187 300w, http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/SublimeText2-MultipleSelections.png?resize=480%2C300 480w" sizes="(max-width: 210px) 100vw, 210px" data-recalc-dims="1" /></a>
                    
                    <p class="wp-caption-text">
                      Selezione multipla e Minimap facilitano notevolmente il lavoro
                    </p>
                  </div></td> </tr> </tbody> </table> 
                  
                  <p>
                    Tra le altre caratteristiche degne di nota segnalo la ricerca e sostituzione via <strong>regular expression</strong>, la selezione multipla, il <strong>completamento automatico</strong>, gli <strong>snippet già pronti</strong>, l&#8217;<strong>automazione</strong> dei processi frequenti, l&#8217;evidenziazione degli elementi del linguaggio (<strong>syntax highlighting</strong>) per ASP, Python, JavaScript, HTML, Java, C#, C++, JSON e molti altri linguaggi. Ci sono decine di <strong>plugin</strong> e il prodotto è seguito con <strong>aggiornamenti frequenti</strong> (che al mio adorato TextMate mancano ormai da troppo da tempo).
                  </p>
                  
                  <p>
                    Unica controindicazione che ho riscontrato finora è la non completa aderenza alle combinazioni di tastiera standard a cui OSX mi ha abituato. Per esempio la combinazione di tasti Command-, (virgola) non richiama le Preferenze come invece succede con qualunque programma Mac-nativo.
                  </p>
                  
                  <p>
                    Se siete alla ricerca di un text editor evoluto non fatevi scappare questa piccola gemma.
                  </p>
                  
                  <p>
                    <em>PS: ho scritto un seguito a questo articolo: <a title="Sublime Text 2 un anno dopo" href="http://nicolaiarocci.com/sublime-text-2-un-anno-dopo/">Sublime Text 2 un anno dopo</a>.</em>
                  </p>

Progetti e Soluzioni

Python Tools è perfettamente integrato nel sistema a progetti tipico di Visual Studio. I file di progetto Python hanno estensione .pyproj e supportano parecchi tipi di applicazione (Console, WPF, MPI, WinForms, ecc.)

Editor

Python Tools supporta gran parte delle caratteristiche che hanno reso famoso l’editor di Visual Studio: evidenziazione degli elementi del linguaggio (syntax color highlighting), riconoscimento di classi e funzioni, navigazione dei metodi nella barra di navigazione, suggerimenti al passaggio del mouse, ricerca di definizioni e occorrenze, IntelliSense.

Debugger

Il potente debugger di Visual Studio è utilizzabile con Python. Valutazione di espressioni (anche nella finestra interattiva), ispezione delle variabili, impostazione dell’istruzione successiva, uscita ed entrata da cicli di codice e/o funzioni (step in, step out).

Object Browser

Python Tools supporta l’uso del Object Browser di Visual Studio 2010. Per ogni modulo è disponibile l’elenco delle classi e, per ogni classe, delle funzioni definite. Il pannello sinistro mostra i moduli e le classi mentre quello destro elenca gli attributi della classe selezionata.

Visto chi l’ha realizzato non stupisce che Python Tools per Visual Studio offra anche funzionalità avanzate quali il Profiling (solo su Visual Studio 2010 Ultimate), cluster computing e cloud computing. Clustering e scaling sono già implementati mentre per il supporto di Windows Azure bisognerà aspettare il prossimo aggiornamento. Già disponibili i port per .NET delle librerie NumPy e SciPy.

Python Tools per Visual Studio non è una distruzione completa di Python. E comunque necessario installare CPython o IronPython. Questa è una buona notizia perché potrai lavorare sia nel modo tradizionale (magari con colleghi abituati ad altre IDE) sia con Visual Studio.

Una grande opportunità

Se vieni dal mondo .NET e sei incuriosito dal linguaggio Python (dovresti esserlo!) questa è la tua occasione. Puoi lavorare con Python senza rinunciare al tuo ambiente preferito e puoi concentrarti sulle caratteristiche del linguaggio risparmiandoti l’apprendimento di una nuova IDE. A dire il vero anche IronPython dispone di un suo plugin per VisualStudio ma ora hai l’opportunità di lavorare con CPython, il Python originale.

Per muovere i primi passi comincia con Impara Python in 10 minuti, guida rapida per il programmatore proveniente da altri linguaggi.

Steve Cheney propone una riflessione su come Facebook condizioni ormai _l’autenticità_ dei suoi utenti. Il timore che conoscenti e amici (alcuni non li incontriamo da anni, altri sono parenti stretti) vedano quel che facciamo online ci induce a comportarci in maniera diversa da quel che sarebbe il nostro istintivo sentire.

2. Tutorial: Microsoft Excel per il SEO

Eccellente tutorial su come usare Excel per analizzare al meglio la quantità di dati che raccogliamo durante le nostre indagini SEO.

3. 10 consigli per velocizzare il caricamento delle pagine Web

La pazienza è la virtù dei forti, ma per molti è una pratica difficile da applicare. Ciò è vero soprattutto per chi visita siti web. Six Revision ci propone una decina di consigli per velocizzare le nostre pagine web.

4. Adobe rilascia un convertitore da Flash a HTML5

   E con questa Adobe ammette, sia pur implicitamente, la morte di Flash. Se mi segui da un pò la mia opinione la conosci già. L’altro giorno al BE-Wizard 2011 il grande Avinash Kaushik ha dichiarato (ero in platea): “ogni volta che usi Flash su una pagina Web, un dolce cucciolo muore”.

5. Tutorial: Aumentare le prestazioni delle applicazioni HTML5

HTML5 ci offre splendidi strumenti per migliorare l’aspetto delle applicazioni web. Animazioni ed effetti richiedono attenzione alle prestazioni. Ecco un ottimo e approfondito tutorial su come evitare il rischio di passare dalla padella alla brace.

6. Apple rilascia Xcode 4

Xcode 4 è la nuova versione del framework Apple per la creazione di applicazioni Mac, iPhone, and iPad. Include la Xcode IDE, Instruments, il simulatore di iOS e le ultime versioni degli SDK per Mac OS X e iOS**.** 

7. Ecco perché tutti parlano di Node

Al ventesimo piano di un grattacielo di San Francisco un gruppo di sviluppatori sta lavorando a una nuova tecnologia che sta cambiando (forse) il modo in cui le applicazioni web in real-time saranno costruite e distribuite. Tutti ne parlano. Ecco perché.

8. 11 Tools Online per Programmatori

I tools online sono ideali per sbrigare rapidamente piccoli lavoretti. Questo articolo ne presenta una selezione originale.

9. SEO: Massimizzare il CTR nelle ricerche organiche

Non perdetevi questo articolo se lavorate in ambito SEO/SERP. _Enough said_.

10. Hai un Blog o un sito web? Aiuta il Giappone con un semplice Banner

Puoi dare una mano inserendo uno snippet di codice che mostra un banner che invita a partecipare alla raccolta fondi per il Giappone avviata dalla Croce Rossa.

Attribuzione

Questo articolo è una traduzione autorizzata di Learn Python in 10 minutes. Ringrazio l’amico Stavros Korokithakis per il permesso di accordatomi.

Caratteristiche

Python è un linguaggio fortemente e dinamicamente tipizzato (i tipi dati esistono e sono necessari ma non è necessario dichiararli esplicitamente), case sensitive (var e VAR sono due variabili diverse) e object oriented (tutto in Python è un oggetto).

Come ottenere aiuto

L’interprete di Python fornisce già un valido sistema di aiuto. Per sapere come usare un oggetto basta digitare help(). Sono utili anche dir, che elenca gli attributi (metodi) disponibili per l’oggetto,  e .__doc__ che mostra la documentazione completa quando disponibile:

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number\n\nReturn the absolute value of the
argument.'

Sintassi

In Python *non ci sono terminatori di riga obbligatori e i blocchi sono specificati con l’ indentazione. Indenta per cominciare un blocco e rimuovi l’indentazione per concluderlo, tutto qui. Le istruzioni che richiedono un blocco indentato terminano con i due punti (:). I commenti cominciano col cancelletto (#) e sono a linea singola. Stringhe su più righe sono usate per i commenti multi linea. Le assegnazioni si compiono col simbolo di uguale (=). Per i test di uguaglianza si usa il doppo uguale (==). Puoi aumentare e diminuire un valore usando gli operatori += e -= seguiti dall’addendo. Ciò funziona con molti tipi di dati, stringhe incluse. Puoi assegnare e usare più variabili sulla stessa riga. Alcuni esempi:

>>> myvar = 3
>>> myvar += 2
>>> myvar
5

>>> myvar -= 1
>>> myvar
4

"""Questo è un commento su più righe.
Le righe seguenti vengono concatenate."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print mystring
Hello world.

# Il codice seguente scambia due variabili in una sola riga.
# Non ci sono errori di conversione di tipo perché
# i nuovi valori non vengono assegnati. Vengono creati
# nuovi oggetti ai quali le variabili fanno ora riferimento.
>>> myvar, mystring = mystring, myvar

Tipi di dati

Le strutture più significative in Python sono liste, tuple e dizionari. I Set sono integrati in Python a partire dalla versione 2.5 (per le versioni precedenti sono disponibili nella libreria sets). Le Liste sono simili ad array mono dimensionali ma è possibile creare liste che contengono altre liste. I dizionari sono array che contengono coppie di chiavi e valori (hash table) e le tuple sono oggetti immutabili mono dimensionali. In Python gli array possono essere di qualunque tipo, quindi puoi mischiare interi, stringhe, ecc nelle tue liste/dizionari e tuple. L’indice del primo oggetto in qualunque tipo di array è sempre zero. Gli indici negativi sono ammessi e contano a partire dalla fine dell’array, -1 indica l’ultimo elemento dell’array. Le variabili possono fare riferimento a funzioni.

>>> esempio = [1, ["un'altra", "lista"], ("una", "tupla")]
>>> mialista = ["Elemento 1", 2, 3.14]
>>> mialista[0] = "Ancora elemento 1"
>>> mialista[-1] = 3.15
>>> miodizionario = {"Key 1": "Valore 1", 2: 3, "pi": 3.14}
>>> miodizionario["pi"] = 3.15
>>> miatupla = (1, 2, 3)
>>> miafunzione = len
>>> print miafunzione(mialista)
3

Puoi ottenere un range di array usando i due punti (:). Non indicare l’indice iniziale del range sottintende il primo elemento; non indicare l’indice finale sottintende l’ultimo elemento. Indici negativi contano a partire dall’ultimo elemento (-1 è l’ultimo elemento dell’array). Quindi:

>>> mialista = ["Elemento 1", 2, 3.14]
>>> print mialista[:]
['Elemento 1', 2, 3.1400000000000001]

>>> print mialista[0:2]
['Elemento 1', 2]

>>> print mialista[-3:-1]
['Elemento 1', 2]

>>> print mialista[1:]
[2, 3.14]

Stringhe

Le stringhe in Python sono indicate *indifferentemente con la virgoletta singola (') o doppia (") ed è consentito usare una notazione all’interno di una stringa delimitata dall’altra ("Egli disse 'ciao'." è valida). Stringhe su più righe sono racchiuse in triple (o singole) virgolette ("""). Python *supporta Unicode, basta ricorrere alla sintassi u"Questa è una stringa unicode". Per inserire valori in una stringa usa l’operatore % (modulo) e una tupla. Ogni % viene sostituito da un elemento della tupla, da sinistra a destra, ed è consentito usare un dizionario per le sostituzioni.

>>> "Nome: %s\nNumero: %s\nStringa: %s" % (miaclasse.nome, 3, 3 * "-")
Nome: Poromenos
Numero: 3
Stringa: ---

strString = """Questa è
una stringa
multi riga."""

# ATTENZIONE: Nota la s finale in "%(key)s".
>>> print "Questo %(verbo)s un %(nome)s." % {"nome": "test", "verbo": "è"}
Questo è un test.

Controllo di flusso

Le istruzioni per il controllo di flusso sono if, for, e while. Non esiste il select; al suo posto si usa if. Il for si usa anche per enumerare i membri di una lista. Per ottenere un elenco di numeri si usa range(numero).

rangelist = range(10)
>>> print rangelist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:
    # Verifica se numer è uno dei
    # numeri nella tupla.
    if number in (3, 4, 7, 9):
        # "Break" termina un for senza
        # eseguire la clausola "else".
        break
    else:
        # "Continue" prosegue con l'iterazione successiva
        # del loop. Piuttosto inutile in questo caso,
        # visto che siamo all'ultima istruzione del loop.
        continue
else:
    # Questo "else" è opzionale ed è
    # eseguito solo se il loop non è stato interrotto
    # con "break".
    pass # Non fa nulla

if rangelist[1] == 2:
    print "Il secondo elemento (le liste sono 0-based) è 2"
elif rangelist[1] == 3:
    print "Il secondo elemento (le liste sono 0-based) è 3"
else:
    print "Non saprei"

while rangelist[1] == 1:
    pass

Funzioni

Le funzioni sono dichiarate con la la parola chiave def. Eventuali *argomenti opzionali vanno dichiarati dopo quelli obbligatori e devono avere un valore assegnato. Quando si chiamano funzioni passando *argomenti per nome è necessario passare anche il valore. Le funzioni possono restituire una tuple (lo spacchettamento delle tuple rende possibile la restituzione di *valori multipli). Le *lambda sono funzioni in linea. I parametri sono passati per riferimento, ma i tipi immutabili (tuple, interi, stringhe, ecc.) non possono essere modificati nella funzione. Questo succede perché viene passata solo la posizione in memoria dell’elemento, e assegnare un altro oggetto alla variabile comporta la perdita del riferimento all’oggetto precedente. Per esempio:

# Equivalente a def f(x): return x + 1
funzionevar = lambda x: x + 1
>>> print funzionevar(1)
2

# un_int e una_stringa sono opzionali, hanno valori di default
# da usare se non vengono passati (2 e "Una stringa", rispettivamente).
def passing_example(una_lista, un_int=2, una_stringa="Una stringa"):
    una_lista.append("Nuovo elemento")
    un_int = 4
    return una_lista, un_int, una_string

>>> mia_lista = [1, 2, 3]
>>> mio_int = 10
>>> print passing_example(mia_lista, mio_int)
([1, 2, 3, 'Nuovo elemento'], 4, "Una stringa")

>>> mia_lista
[1, 2, 3, 'Nuovo elemento']

>>> mio_int
10

Classi

Python supporta la ereditarietà multipla delle classi. Le variabili e i metodi privati vengono dichiarati per convezione (non è una regola del linguaggio) precedendoli con due underscore (_). Possiamo assegnare attributi (proprietà) arbitrari alle istanze di una classe. Un esempio:

class MiaClasse:
    comune = 10
    def __init__(self):
        self.miavariabile = 3
    def miafunzione(self, arg1, arg2):
        return self.miavariabile

# Creiamo una istanza della classe
>>> istanza = MiaClasse()
>>> istanza.miafunzione(1, 2)
3

# Questa variabile è condivisa da tutte le istanze
>>> istanza2 = MiaClasse()
>>> istanza.comune
10

>>> istanza2.comune
10

# Nota come qui usiamo il nome della classe
# invece dell'istanza.
>>> MiaClasse.common = 30
>>> instanza.common
30

>>> instanza2.common
30

# Questo non aggiornerà la variabile nella classe,
# invece assegnerà un nuovo oggetto alla variabile
# della prima istanza.
>>> istanza.common = 10
>>> istanza.common
10

>>> istanza2.common
30

>>> MiaClasse.common = 50

# Il valore non è cambiato perché "common"
# ora è una variabile dell'istanza.
>>> istanza.common
10

>>> istanza2.common
50

# Questa classe eredita da MiaClasse. L'ereditarietà
# multipla viene dichiarata così:
# class AltraClasse(MiaClasse1, MiaClasse2, MiaClasseN)
class AltraClasse(MiaClasse):
    # L'argomento "self" è passato automaticamente
    # e fa riferimento all'istanza della classe, quindi puoi impostare
    # variabili di istanza come sopra, ma dall'interno della classe.
    def __init__(self, arg1):
        self.miavariabile = 3
        print arg1

>>> istanza = AltraClasse("hello")
hello

>>> istanza.miafunzione(1, 2)
3

# Questa classe non ha un membro (proprietà) .test member, ma
# possiamo aggiungerne uno all'istanza quando vogliamo. Nota
# che .test sarà un membro della sola istanza.
>>> istanza.test = 10
>>> istanza.test
10

Eccezioni

Le eccezioni in Python sono gestite con dei blocchi try-except [nome_eccezione]:

def una_funzione():
    try:
        # Divisione per zero causa una eccezione
        10 / 0
    except ZeroDivisionError:
        print "Oops, errore."
    else:
        # Non c'è stata eccezione, possiamo proseguire.
        pass
    finally:
        # Questo codice viene eseguito quando il blocco
        # try..except è già eseguito e tutte le eccezioni
        # sono state gestite, anche se si verifica una nuova
        # eccezione direttamente nel blocco.
        print "Abbiamo finito."

>>> una_funzione()
Oops, errore.
Abbiamo finito.

Importare librerie

Le librerie esterne si importano con import [nomelibreria]. Puoi anche usare la forma [nomelibreria] import [nomefunzione] per importare singole funzioni. Ecco un esempio:

import random
from time import clock

randomint = random.randint(1, 100)

>>> print randomint
64

Input e Output

Python vanta una vasta gamma di librerie per gestire input/output di files. In questo esempio vediamo come serializzare (convertire strutture dati in stringhe) usando la libreria pickle:

import pickle
mialista = ["Questo", "è", 4, 13327]

# Apre il file C:\binary.dat in scrittura. La lettera r
# prima del nome file serve a evitare l'escaping
# del backslash.
miofile = file(r"C:\binary.dat", "w")

pickle.dump(mialista, miofile)
miofile.close()

miofile = file(r"C:\text.txt", "w")
miofile.write("Questa è una stringa di prova")
miofile.close()

miofile = file(r"C:\text.txt")

>>> print miofile.read()
'Questa è una stringa di prova'

miofile.close()

# Apre il file in lettura.
miofile = file(r"C:\binary.dat")
listadafile = pickle.load(miofile)
miofile.close()

>>> print listadafile
['Questo', 'è', 4, 13327]

Varie ed eventuali

I *test possono essere concatenati. 1 > a < 3 verifica che a sia minore di  3 e maggiore di 1. Puoi usare del per cancellare variabili o elementi di array. Le comprensioni di lista sono uno strumento potente per creare e manipolare le liste. Consistono in una espressione seguita da una clausola for seguita da zero o più clausole if. Quindi:

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print [x * y for x in lst1 for y in lst2]
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print [x for x in lst1 if 4 > x > 1]
[2, 3]

# Verifica se almeno un elemento ha una determinata
# caratteristica.
# "any" restituisce true se qualunque elemento nella
# lista è vero.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# Funziona perché 4 % 3 = 1, e 1 in Python è true,
# quindi any() restituisce True.

# Verifica quanto elemento hanno una determinata
# caratteristica.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2

>>> del lst1[0]
>>> print lst1
[2, 3]

>>> del lst1

Le variabili globali vengono dichiarate all’esterno delle funzioni senza dichiarazioni particolari, ma se desideri modificarle in una funzione devi dichiararle con la parola global all’inizio della funzione, altrimenti Python assegnerà quell’oggetto a una nuova variabile locale (presta attenzione, si tratta di un piccolo dettaglio che può metterti facilmente nei guai). Per esempio: numero = 5

def miafunz():
    # Questo stamperà 5.
    print numero

def altrafunz():
    # Questo solleva una eccezione perché la variabile
    # non è stata ancora assegnata. Python crea un
    # nuovo oggetto locale invece di accedere al globale
    print numero
    numero = 3

def ancorafunz():
    global numero
    # Questo cambierà il valore alla variabile globale
    numero = 3

Epilogo

Questa non intende essere una guida completa (e nemmeno parziale) a Python. Python ha una vasta gamma di librerie e molte, moltissime funzionalità che dovrai scoprire con altri mezzi, come Dive Into Python (tradotto in italiano) o l’eccellente Learning Python di Mark Lutz, libro che consiglio a chiunque voglia davvero imparare e capire Python.

Mi auguro di averti aiutato nella transizione verso Python. Lasciami un commento se pensi che ci sia qualcosa da migliorare o se c’é qualcos’altro che vorresti approfondire.

Sono @nicolaiarocci su Twitter.

Ecco una comoda routine che fa al caso nostro. Dopo averla eseguita vi troverete il database completamente vuoto, come se fosse stato appena creato.

Anche questa routine (come quella vista ieri che cancella le sole Stored Procedure) accede alla tabella di sistema sys.objects per reperire lo schema del database. Cambia però la tecnica di accesso alle informazioni. Invece di usare un cursore qui selezioniamo il primo record utile per poi inoltrarci in un ciclo di cancellazioni ripetute. Il ciclo termina quando non ci sono più record che soddisfano i parametri di ricerca. Per evitare problemi coi vincoli relazionali è importante cancellare prima le relazioni e solo dopo le tabelle.

Nota Bene

Probabilmente c’è una ottima ragione per cui non disponete dei diritti di cancellazione del database. Prima di lanciare questo codice chiedetevi almeno dieci volte se 1) state sul database giusto, 2) siete coscienti delle conseguenze di quel che state per fare e 3) disponete di un backup dei dati. In ogni caso se perdete dati preziosi non venite a lamentarvi dal sottoscritto! 😉

La tecnica è quella di sfruttare la tabella di sistema sys.objects che elenca tutti gli oggetti contenuti nel database. Le Stored Procedure hanno tutte type = ‘P’ per cui è facile individuarle. A questo punto ci sono due possibilità: memorizzarne i nomi in una tabella temporanea per poi lanciare un loop che le cancelli una per una, oppure usare un cursore ed eseguire le cancellazioni con la funzione EXEC. La nostra routine usa il secondo approccio, senz’altro più performante.

1. SEO non è più una strategia valida per le Startup

   Opinione fuori dal coro quella di Chris Dixon, CEO di Hunch e investitore seriale (Skype, Foursquare, Stack Overflow e altri). Chris sostiene che le Startup dovrebbero smetterla di puntare su SEO. Alla base del successo di molte Startup dell’ultimo decennio, l’industria SEO è cresciuta talmente che il mercato ne é saturo. Al punto che Google ormai fatica a distinguere i contenuti di qualità da quelli SEO-optimized. Nei commenti una discussione vivace alle quale partecipano investitori famosi e SEO guru internazionali.

2. Analisi sullo sviluppo di applicazioni per Smartphone

Secondo molti lo sviluppo di applicazioni mobile è il futuro. Ma quale è la piattaforma sulla quale puntare investendo tempo e denaro? Mario Concina ci offre una bella panoramica su linguaggi, costi e pro e contro di ognuna delle piattaforme tecnologiche più importanti (iPhone, Android, Windows Mobile, Symbian, BlackBerry)

3. **[Settimana ricca di avvenimenti anche questa. SEO, Startup e applicazioni per Smartphone in primo piano ma non mancano altre chicche per buongustai. Al decimo posto una curiosità non ha nulla da spartire con gli argomenti trattati di solito, ma quelle foto dovevo segnalarvele. Ringrazio chi mi ha contattato via mail, Facebook e Twitter. A quanto pare la rubrica piace e farò il possibile per portarla avanti migliorando la qualità delle selezioni, come sempre assolutamente arbitrarie.

1. SEO non è più una strategia valida per le Startup

Opinione fuori dal coro quella di Chris Dixon, CEO di Hunch e investitore seriale (Skype, Foursquare, Stack Overflow e altri). Chris sostiene che le Startup dovrebbero smetterla di puntare su SEO. Alla base del successo di molte Startup dell’ultimo decennio, l’industria SEO è cresciuta talmente che il mercato ne é saturo. Al punto che Google ormai fatica a distinguere i contenuti di qualità da quelli _SEO-optimized_. Nei commenti una discussione vivace alle quale partecipano investitori famosi e SEO guru internazionali.

2. Analisi sullo sviluppo di applicazioni per Smartphone

Secondo molti lo sviluppo di applicazioni mobile è il futuro. Ma quale è la piattaforma sulla quale puntare investendo tempo e denaro? Mario Concina ci offre una bella panoramica su linguaggi, costi e pro e contro di ognuna delle piattaforme tecnologiche più importanti (iPhone, Android, Windows Mobile, Symbian, BlackBerry)

3. ]3 Molte Startup lanciano in questi giorni prodotti e soluzioni che promettono di semplificare la creazione di applicazioni mobile. In questo articolo PC World ne presenta cinque. Alcune promettono la luna: creazione rapida di applicazioni mobile per tutti, programmatori e non.
4. Programmatori che non sono Designer, Designer che non sono Programmatori

Il programmatore incapace di accoppiare due colori. Il designer inetto col codice. O ci riconosciamo in una di queste figure (io nella prima), o ne abbiamo incontrate nella nostra carriera. Questo breve articolo ne traccia il profilo.

5. Facebook e i nuovi commenti sincronizzati

Facebook è in gran spolvero di questi tempi. Solo quindici giorni fa aggiornava subdolamente il Like Button e questa settimana mette mano al plugin dei Commenti. La novità è destinata a influire pesantemente sulla penetrazione di Facebook nel ‘resto della rete’. Con la solita dovizia di particolari BigThink ci spiega gli aspetti pratici di questo aggiornamento.

<a style="font-weight: bold;" href="http://www.bigthink.it/facebook-e-i-nuovi-commenti-sincronizzati/"></a>

6. Startup.Wikli.it

Startup, web, acquisizioni e venture capital. Wikli seleziona e commenta le news tematiche più interessanti della settimana, le confeziona e te le fa trovare puntuali nella casella di posta ogni venerdì alle 8.00. Idea brillante e molto ben congegnata. Vi invito ad iscrivervi a questa innovativa mailing list. Non ve ne pentirete.

7. YepLike! Startup in 72 ore

In preda a delirio febbricitante Fabio Lalli si inventa una idea da lanciare in 72 ore. Leggete il suo racconto. PS: nel frattempo le 72 ore sono trascorse, l’applicazione è su iPhone e a quanto pare riscuote buon successo.

8. Venti consigli pratici per il programmatore

Di post di questo tipo se ne trovano tanti in rete ma questo mi ha colpito perché contiene alcune chicche interessanti che denotano esperienza diretta da parte dell’autore. Da non perdere se siete principianti. Se siete esperti vi riconoscerete senz’altro in alcune di queste situazioni.

9. Quale è il libro fondamentale che ogni programmatore dovrebbe leggere nella vita?

Su Stack Overflow se ne è discusso a lungo. Il risultato è una selezione di alcuni tra i libri più importanti di sempre. Il fatto che il Kernighan & Ritchie non sia il primo in classifica la dice lunga sulla mia vetustità. Sono un collezionista di prime edizioni, ammetto che vedere riuniti così tanti testi fondamentali mi ha fatto prudere le mani.

10. Shackleton, L’Antartide a Colori – 1915

Nel 1915 Shackleton e i suoi uomini furono costretti ad abbandonare la ‘Endurance’, inesorabilmente intrappolata dai ghiacci. Frank Hurley, il fotografo dela spedizione, riuscì miracolosamente a salvare le lastre fotografiche di quella spedizione. In questa magnifica galleria vediamo le foto (a colori) di quella spedizione

Il sito invita i web master di tutto il mondo a unirsi alla crociata per la distruzione della vetusta reliquia aggiungendo un banner alle loro home page. Il banner compare solo quando la pagina è aperta da IE6, spiegando al visitatore che il suo browser è obsoleto e di scarsa qualità (questo in effetti dimentica di dirlo) e suggerendo di aggiornarlo.

E’ probabile che decine di migliaia di siti adotteranno il banner. E’ interesse comune che IE6 abbandoni le scene al più presto. Tutti vorremmo che le nostre pagine venissero visitate da browser moderni che supportano HTML5 e CSS3. Giusto?

Piccolo dettaglio insignificante

C’è però un dettaglio, prontamente segnalato da Steve Webster, che non quadra. Cliccando sul banner veniamo indirizzati al sito di Internet Explorer dove siamo invitati a scaricare l’ultimo aggiornamento. Quando va bene chi oggi usa ancora IE6 sta su piattaforma Windows XP. E’ cosa nota che Internet Explorer 9 non gira su sistemi precedenti a Vista SP2. L’unica opzione di aggiornamento valida rimane…

…Internet Explorer 8. Un browser vecchio di due anni che si trova sull’orlo dell’obsolescenza e non supporta affatto HTML5. Certo sempre meglio di IE6 ma c’è in giro di molto meglio, non trovate? Fate la cosa giusta e mettete mano al codice che trovate su IE6countdown.com. Fate puntare il vostro banner a Chrome, Firefox, Opera o Safari. Già che ci siete aggiungete il tag alt (se lo sono scordato) e sostituite l’immagine con una che non ricordi gli anni 90 del secolo scorso.

Avidità

Il problema della avidità degli operatori regex diventa evidente quando si comincia a lavorare su ricerche avanzate. Un caso tipico è il parsing di file XML o HTML.

<p>questo è un <b>paragrafo</b></p>

Supponiamo di voler trovare tutti i tag usati.

<.*> # cerca tutti i tag

Il risultato della query non è quello che ci si potrebbe aspettare. L’operatore * è avido, ovvero cerca di catturare più caratteri possibili. Una volta trovato il primo < prosegue avidamente selezionando tutto fino all’ultimo >. In questo caso vogliamo che si fermi al primo >, non all’ultimo. E’ questa una distinzione importante, da comprendere a fondo. Possiamo disattivare il comportamento avido aggiungendo il carattere?

<.*?> # ora otteniamo quel che vogliamo (niente avidità)

Se desideriamo usare l’operatore + (1 o più) al posto del * (zero o più), la nostra query diventa <.+?>.

Confini

Nella seconda parte del nostro tutorial abbiamo convalidato un numero telefonico nel formato 555-12345678

555-\d{8}   # 555- seguito da 8 cifre

Anche se tecnicamente corretta questa query non è perfetta. Se la testiamo con queste stringhe:

testoDavanti 555-12345678
555-12345678 il mio telefono

scopriamo che vengono accettate perché la regola 555-\d{8} è ancora valida. In realtà noi desideriamo accettare il solo il numero telefonico, niente altro. La soluzione richiede l’uso degli operatori di confine:

^555-\d{8}$

I confini sono caratteri speciali perché non occupano spazio. Sono dei segnaposto che servono a delimitare il testo da cercare. Dopo l’inizio (^) deve esserci il nostro numero di telefono; prima della fine ($) deve esserci il nostro numero di telefono.

<th>
  significato
</th>

<td style="vertical-align: top;">
  Inizio del testo. Sfortunatamente gli inventori di regex hanno scelto lo stesso carattere usato per la negazione. E&#8217; importante riconoscerne il significato in base al contesto. Quando non è compreso tra [ e ] il carattere ^ è un confine e indica l&#8217;inizio del testo.
</td>

<td>
  fine del testo
</td>

Quindi

a   #  trova qualunque a
^a  #  trova solo il testo che comincia per a
a$  #  trova solo il testo che finisce per a

C’è un altro confine, quello di parola (\b). Vediamo un esempio. Vogliamo cercare le parole “for” e “she” nella nostra pagina di test.

(for|she)  # trova for e she

Non va male. Trova tutte le occorrenze di “she” e “for”, tuttavia viene selezionata anche la parola “before”. Non è il comportamento desiderato. Potremmo tentare cercando solo le occorrenze precedute e succedute da uno spazio.

[ ](for|she)[ ]  # cerca for o she

Va meglio. Non seleziona più before. Abbiamo però un nuovo problema. Nel testo c’è la frase “for she had plenty of time”. La nostra regex non ha individuato la parola “she” contenuta nella frase. Per quale motivo?

for she had plenty of time

Con il “for” iniziale abbiamo già rintracciato lo spazio che precede “she”, che quindi viene escluso. Sono queste le situazioni un cui un confine di parola può risolvere il problema.

\b(for|she)\b  # trova she oppure for

Il confine \b definisce dove la parola comincia e finisce, proprio come succede con i confini visti prima. Abbiamo detto prima che i “confini non occupano spazio”. Nell’esempio qui sopra cerchiamo esattamente “for” o “she”. Non cerchiamo la stringa \b e questa non occupa alcuno spazio durante la ricerca, a differenza di quel che è successo quando abbiamo tentato di usare la [cornice]. E’ un dettaglio importate perché con tutti gli altri operatori regex ciò che è nella query “occupa spazio” e non può essere trovato di nuovo.

Il Finale: Ricerca e Sostituzione

Ce l’hai fatta! Sei arrivato in fondo. Congratulazioni. Il meglio arriva ora. Ricerca e sostituzione è senz’altro il mio argomento preferito. Qui la pagina di test non ci può aiutare, occorre qualche tipo di editor oppure una IDE (Eclipse/Notepad++/Wordpad).

Supponiamo di avere un file composto da 100 righe come queste

31-01-10_backup32
24-01-10_backup1
24-02-10_backup_mona
11-03-09_backup_lisa

Vogliamo correggere le date portandole dal formato europeo a quello americano (da gg-mm-aa a mm-gg-aaaa).

\d{2}-\d{2}-\d{2}_backup.*  // trova le nostre righe

Per ogni riga desideriamo sostituire aree specifiche quindi ricorriamo all’operatore di raggruppamento già visto nella seconda parte di questa guida.

(\d{2})-(\d{2})-(\d{2})_backup(.*)  // ci siamo

A questo punto tutto quel che dobbiamo fare è sostituire le righe trovate con

{Gruppo2}–{Gruppo1}-20{Gruppo3}_backup{Gruppo4}

Il che si traduce nella seguente espressione di sostituzione

\2-\1-20\3_backup\4

Facile no? Niente più lavori ripetitivi. La mia regola è: se un testo richiede la modifica di più di cinque righe è giunta l’ora di ricorrere alle regex. Potrebbe sembrare una esagerazione. Eppure un programmatore dovrebbe rifiutarsi per principio di ripetere manualmente un lavoro che può essere automatizzato.

Buona fortuna.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 3. Ringrazio l’autore per il permesso accordatomi.

JSON

JSON è un formato di scambio dati sempre più diffuso. Un flusso di dati JSON è relativamente compatto (soprattutto rispetto al suo rivale XML) ed è facile da interpretare sia per un umano che per un computer. Ormai tutte le Web API più usate (Facebook, Twitter, ecc.) supportano ampiamente JSON. Ecco un esempio di array JSON:

JavaScript

Dopo aver scaricato la libreria includiamola nella nostra pagina:

Tempo.prepare(element)

Tempo.Prepare() cerca uno o più data-template in un contenitore HTML, li mette in cache e li rimuove dalla pagina (verranno sostituiti dai dati in fase di rendering). Restituisce infine una istanza specializzata del renderer che, grazie alle indicazioni contenute nei data-template, sa già come mostrare i dati. Se stiamo usando jQuery possiamo passare direttamente l’oggetto jQuery.

renderer.render(data)

Il metodo render si applica alla instanza del renderer restituita da Tempo.prepare(). Accetta come argomento i dati JSON e li mostra finalmente nella nostra pagina HTML.

HTML

Tempo riconosce come template qualunque tag con attributo data-template che sia contenuto nell’elemento HTML da noi indicato. Indichiamo i campi dell’array JSON col nome racchiuso tra doppie parentesi {{}}

il codice viene reso con:

Per le funzionalità avanzate (condizioni se-allora, data-template nidificati, supporto jQuery e gestione callbacks ed eventi) vi rimando alla pagina ufficiale della libreria, dalla quale peraltro ho tratto gran parte di questo esempio. Vi trovate anche un esempio funzionante di rendering di un flusso proveniente da Twitter e recuperato via jQuery.

Già un mese fa presentando il Progetto Orion accennavo a Cloud9, allora in beta avanzata. Erano disponibili pochi dettagli e soprattutto mancavano i prezzi. Partiamo dalle caratteristiche salienti.

Punti di forza

Cloud9 si vanta di possedere il miglior editor online per linguaggi dinamici. In effetti l’editor è un progetto originale Mozilla (Skywriter), poi integrato in Ace. Il codice viene convalidato in tempo reale ed è possibile fare debug e lanciare applicazioni direttamente dal browser. Molte le funzioni per la collaborazione: chat integrato, modifiche condivise in tempo reale, team management e, dulcis in fundo, integrazione completa con GitHub (una UI per GitHub è in lavorazione, al momento è disponibile la classica linea di comando). Vedere per credere:

      <p class="wp-caption-text">
        Editor per linguaggi dinamici integrato nel browser
      </p>
    </div></td> 
    
    <td>
      <p>
        <div id="attachment_1274" style="width: 220px" class="wp-caption alignright">
          <a href="images/cloud9_2.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1274  " title="Convalida del codice JavaScript in tempo reale" src="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_2-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
          
          <p class="wp-caption-text">
            Convalida del codice JavaScript in tempo reale
          </p>
        </div></td> </tr> 
        
        <tr>
          <td>
            <p>
              <div id="attachment_1275" style="width: 220px" class="wp-caption alignright">
                <a href="http://i2.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_21.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1275   " title="Chat intengrato in Cloud9" src="images/cloud9_21-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                
                <p class="wp-caption-text">
                  Chat intengrato in Cloud9
                </p>
              </div></td> 
              
              <td>
                <p>
                  <div id="attachment_1276" style="width: 220px" class="wp-caption alignright">
                    <a href="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_4.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1276    " title="Gruppi di lavoro" src="http://i0.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_4-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                    
                    <p class="wp-caption-text">
                      Gruppi di lavoro
                    </p>
                  </div></td> </tr> 
                  
                  <tr>
                    <td>
                      <p>
                        <div id="attachment_1277" style="width: 220px" class="wp-caption alignright">
                          <a href="images/cloud9_5.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1277  " title="Run e Debug online" src="http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_5-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                          
                          <p class="wp-caption-text">
                            Run e Debug online
                          </p>
                        </div></td> 
                        
                        <td>
                          <p>
                            <div id="attachment_1278" style="width: 220px" class="wp-caption alignright">
                              <a href="images/cloud9_6.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1278  " title="Integrazione con GitHub" src="http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_6-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                              
                              <p class="wp-caption-text">
                                Integrazione con GitHub
                              </p>
                            </div></td> </tr> 
                            
                            <tr>
                              <td>
                                <p>
                                  <div id="attachment_1279" style="width: 220px" class="wp-caption alignright">
                                    <a href="http://i2.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_7.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1279  " title="Team Management" src="images/cloud9_7-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                                    
                                    <p class="wp-caption-text">
                                      Team Management
                                    </p>
                                  </div></td> 
                                  
                                  <td>
                                    <p>
                                      <div id="attachment_1280" style="width: 220px" class="wp-caption alignright">
                                        <a href="images/cloud9_8.png" rel="lightbox[1208]"><img class="size-thumbnail wp-image-1280  " title="Accedi al codice ovunque tu sia" src="http://i1.wp.com/nicolaiarocci.com/wp-content/uploads/cloud9_8-150x100.png?w=150" alt="" data-recalc-dims="1" /></a>
                                        
                                        <p class="wp-caption-text">
                                          Accedi al codice ovunque tu sia
                                        </p>
                                      </div></td> </tr> </tbody> </table> 
                                      
                                      <h2>
                                        Linguaggi e Frameworks
                                      </h2>
                                      
                                      <p>
                                        JavaScript naturalmente è supportato al 100%. Ruby anche, seppure parzialmente. Cloud9 mira a integrare tutti i linguaggi e i framework più diffusi. Per quanto riguarda i linguaggi della galassia Microsoft per ora nulla da fare (ma c&#8217;è sempre <strong><a href="http://www.coderun.com/">CodeRun</a></strong>), anche se ho colto un (molto) blando accenno a un futuro supporto per Mono. Cloud9 supporterà il <em>one-click-deploy</em> su altre piattaforme cloud e il mounting di drive locali per consentire l&#8217;accesso ai files remoti da parte di applicazioni esterne. Insomma il menù è ricco e invitante, bisognerà vedere a che ritmo si succederanno le implementazioni.
                                      </p>
                                      
                                      <h2>
                                        Piani tariffari
                                      </h2>
                                      
                                      <p>
                                        Qui la faccenda si fa ancor più interessante e per certi versi sorprendente. I progetti open source possono accedere a Cloud9 gratuitamente. Quelli commerciali possono scegliere tra due piani tariffari, uno giornaliero (€0.33/giorno) e uno mensile (€39/mese). Il piano giornaliero mi incuriosisce parecchio. Se ho ben capito si pagano solo i giorni di uso effettivo, se così fosse si tratterebbe di una soluzione davvero valida oltre che originale. Ad ogni buon conto è previsto un periodo di prova di 30 giorni.
                                      </p>
                                      
                                      <h2>
                                        Coraggio!
                                      </h2>
                                      
                                      <p>
                                        Sono intrigato un bel pò, l&#8217;avrete capito. Le titubanze sono legittime, per carità. Sicurezza e riservatezza sono aspetti importanti; queste piattaforme cloud potranno garantirle? Molti di noi hanno superato da tempo queste paure appoggiandosi (per progetti aperti e privati) a GitHub, Mercurial e altri servizi repository. E&#8217; forse giunto il momento di cominciare a sporcarsi le mani. Prima o poi dovremo farci i conti comunque, non credete?
                                      </p>

Like Button: Facebook cambia le regole

Questa settimana Facebook ha sorpreso tutti cambiando radicalmente il funzionamento del pulsante Mi Piace. Su BigThink Daniele Ghidoli è tra i primi ad accorgersene e a segnalare la novità. Leggi l’articolo su BigThink.

Google migliora l’algoritmo di indicizzazione del web

Negli ultimi mesi le critiche sulla qualità ****delle ricerche Google si sono moltiplicate. Le famigerate content farm hanno conquistato le prime posizioni per molte ricerche sulle keyword più importanti. Il gigante di Mountain View annuncia a sorpresa la contromossa, ossia l’aggiornamento del suo algoritmo più importante. L’obiettivo è penalizzare i siti di scarsa qualità e migliorare il ranking di quelli con contenuti validi. Leggi l’annuncio sul blog ufficiale di Google.

E’ in arrivo una nuova Bolla delle Dot-Com?

Le incredibili valutazioni economiche di servizi come Twitter e Facebook inducono molti a sostenere che ci troviamo nel bel mezzo della seconda bolla delle Dot-Com, declinata questa volta ai social network. TagliaBlog pubblica la traduzione di un bell’articolo del Wall Street Journal che, prendendo spunto dalla situazione di Twitter, tenta di fare il punto della situazione. Leggi l’articolo su TagliaBlog

Come un Tweet sbagliato può portare al successo commerciale (e a una raccolta di sangue)

Quando Gloria Huang si accorge di aver twittato per sbaglio la sua richiesta di birra fresca dall’account del datore di lavoro (la Croce Rossa) non immagina certo di scatenare una donazione di sangue di massa e il successo commerciale della sua birra preferita. Leggi questa storia sul sito della CNN

Lo stato attuale del Web Design: Trends 2010

Il Web Design sta vivendo un’epoca d’oro. Abbiamo a disposizione strumenti potenti (CSS3, HTML5, il font-embedding), migliaia di risorse gratuite e decine di vivaci comunità online. Ma quali sono le nuove tendenze? Quali le tecniche, i concetti e le idee che si stanno affermando? Questa settimana Smashing Magazine tenta di anticipare il Web Design del prossimo futuro. Leggi l’articolo di Smashing Magazine.

Diffondiamo la Cultura Digitale in Italia

Interessante il progetto Cultura Digitale curato e ideato da Fabio Lalli e dagli Indigeni Digitali. “Si vuole creare un libro gratuito da distribuire on line e off line che parli della Cultura Digitale, di cosa significa per ognuno di noi”. Chiunque può contribuire pubblicando il proprio pensiero sul wall di Cultura Digitale. L’idea è ingegnosa e ben implementata. Funziona anche perché solletica l’ego di ognuno di noi e sfrutta abilmente i meccanismi virali propri del web 2.0. I contributi affluiscono copiosi.  Visita il sito di Cultura Digitale

Mono 2.10

La versione 2.10 di Mono, la piattaforma open source e multi piattaforma alternativa al Microsoft NET Framework, è stata rilasciata questa settimana. Tra le novità aggiornamenti ai compilatori C# e VB, supporto a MVC3, F# e Native Client Google oltre alla soluzione di molti problemi conosciuti. Leggi le Release Notes ufficiali.

Python 3.2

Questa è anche la settimana che ha visto l’uscita dell’ultima release del linguaggio Python, la 3.2. La documentazione ufficiale è stata aggiornata con un documento che illustra accuratamente le novità introdotte con questo aggiornamento. Leggi le novità su Python 3.2.

Google Cloud Connect

Google Cloud Connect è un plugin per Microsoft Office che consente di sincronizzare i documenti Office appoggiandosi alla piattaforma Google Docs. Rilasciato da Google, questo plugin rende semplice la collaborazione tra utenti che non vogliono o non possono rinunciare alla suite Microsoft. I documenti possono essere aggiornati sia offline che online. Leggi tutto su Google Cloud Connect.

I 5 migliori tool gratuiti per SQL Server

Sei pigro e la tua azienda è al verde. Che fare? Brent Ozar, guru SQL Server e uno dei progettisti di Stack Overflow, propone cinque tools gratuiti per la gestione e manutenzione di SQL Server. Leggi l’articolo sul sito di Brent Ozar.

Introduzione alle Regular Expression

Concludo con una svergognata auto promozione. Introduzione alle Regular Expression è una serie in tre parti, attualmente in pubblicazione, che ha l’ambizione di consentire a chiunque di avvicinarsi alle Regular Expression. Le RegEx sono un strumento potente e spesso incompreso, utile non solo ai programmatori ma a chiunque abbia a che fare con le ricerche su testo. Leggi la prima parte della Introduzione alle Regular Expression.

Vi è piaciuta questa selezione? Fatemi sapere che ne pensate con un bel commento qui sotto, lo apprezzerei molto. Alla prossima settimana!

Negazione [^]

Abbiamo già conosciuto la [cornice]. Una caratteristica importante di cui non abbiamo ancora parlato è la negazione. Supponiamo di voler cercare qualunque carattere eccetto la lettera a.

[^a] # trova b,c,d,e,f,\n .... qualunque carattere eccetto 'a'

La negazione si applica a tutti i caratteri della cornice in cui compare l’operatore ˆ. Non è possibile limitarla a solo alcuni.

[^0123456789] # trova qualunque carattere non numerico

Gli Alias

Ora siamo pronti per affrontare qualche esempio realistico di regular expression. Uno degli usi più frequenti delle regex è la convalida di Stringhe. Proviamo a verificare la correttezza di un ipotetico numero telefonico da esprimere nel formato 555-12345678. Di norma divideremmo l’input in due parti e proveremmo a convertirle in numeri. Ora tuttavia conosciamo le regex e possiamo sbrigarcela meglio.

555-[0-9]{7}

Fatto. Stiamo convalidando 555 seguito da un trattino seguito da 7 caratteri numerici. Possiamo essere addirittura più sintetici, vediamo come.

I range [0-9] e [a-z]  sono talmente frequenti da saltar fuori continuamente, tanto che sono state create scorciatoie (alias) dedicate ai range più usati. Nel nostro caso ci torna utile \d, che sta per digit (carattere numerico) ed è semanticamente identico a [0-9].

555-\d{7} # identico a 555-[0-9]{7}

Gli alias non sono certo indispensabili, puoi ottenere gli stessi risultati usando la cornice in modo esteso. Tuttavia sono molto comodi.

<th>
  significato
</th>

<th>
  coorrisponde a
</th>

<td>
  digit (numero)
</td>

<td>
  [0-9]
</td>

<td>
  word (parola)
</td>

<td>
  [a-zA-Z0-9_]  Include il carattere underscore
</td>

<td>
  spazio, tab o newline
</td>

<td>
  [ \t\r\n]
</td>

<td>
  qualsiasi non numerico
</td>

<td>
  ^\d
</td>

<td>
  quasiasi non alfanumerico
</td>

<td>
  ^\w
</td>

<td>
  quasiasi ma non lo spazio
</td>

<td>
  ^\s
</td>

Suggerimento: nota come ad ogni alias ne corrisponde uno dal significato opposto, tutto in maiuscolo. Impara i primi tre per conoscerli tutti e sei.

Il Punto

Il punto è un alias un pò speciale. Ne parlo soprattutto perchè può capitare di notarlo nel codice scritto da altri. Il punto cerca tutto eccetto il new line (\n). Il problema è che il carattere new line non è lo stesso su tutte le piattaforme.

.   # trova tutti i caratteri
.*  # equivalente a [^\n], trova tutti i paragrafi

Il punto spesso crea confusione. Consiglio di ricorrere a combinazioni di alias e cornici per ottenere gli stessi risultati senza rischiare errori.

Escaping

Capita a volte di dover cercare proprio il punto, oppure i caratteri [ o ]. Poiché fanno parte della sintassi regex in questi casi è necessario riccorrere all’escaping, ovvero precederli col carattere \ che rappresenta l’escape. Per esempio

\.    # cerca il punto invece che tutto quanto
\*    # trova tutti gli asterischi
\\    # trova tutti gli escape

Raggruppamenti e OR

Torniamo alla convalida. Questa volta vogliamo verificare la validità di un indirizzo email. Prima di tutto stabiliamo le regole (semplificate) a cui una stringa deve attenersi per venire convalidata come indirizzo email: 1) il nome utente può contenere lettere, numeri, underscore e trattini ma deve cominciare con una lettera; 2) il dominio può contenere solo lettere seguite da un punto seguito da altre lettere. Quindi domain.fakecom è valido per noi

[a-z][\w-]*@[a-z]+\.[a-z]+

Presta attenzione all’escaping del punto! Un’altro dettaglio importante è il quantificatore + che abbiamo visto nel primo articolo di questa serie. Nel dominio infatti vogliamo almeno una lettera, non zero o più.

Supponiamo ora di voler aggiornare le regole in modo da convalidare solo i domini più importanti. Il nostro indirizzo email deve finire con com oppure net. Non possiamo risolvere questo problema con quel che abbiamo imparato finora. La nostra query regex dovrà ricorrere a due nuovi concetti, l’operatore OR e i gruppi.

[a-z][\w-]*@[a-z]+\.(com|net)

Vediamo l’OR all’opera

com|net  #  trova com oppure net
a|b|c    # lo stesso di [abc].

L’aggiunta delle parentesi () si rende necessaria per chiarire che non vogliamo trovare tutte le occorrenze della parte di regex alla loro sinistra. Se volessimo “Brad Pitt” oppure “Angelina Pitt”

Brad|Angelina Pitt  # trova sia 'Brad' che 'Angelina Pitt'
(Brad|Angelina) Pitt  # ora ci siamo!

Per un programmatore il concetto del raggruppamento (grouping) con le parentesi dovrebbe essere facilmente comprensibile. Di fatto possiamo combinarlo con altri operatori che già conosciamo

(dog)+   #  trova dog,dogdog,dogdogdog ...
java(bean)?    #  trova java o javabean

Conclusione

Questo conclude la seconda parte della guida. La prossima e ultima parte verrà pubblicata tra qualche giorno. Nel frattempo raccomando di giocare con la pagina demo per fare un pò di pratica.

E’ ora disponibile anche la terza parte di questo tutorial.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 2. Ringrazio l’autore per il permesso accordatomi.

1. Valide in ogni linguaggio e indipendenti dalla piattaforma, le regex sono un investimento sempre valido. Java, JavaScript, Ruby, .Net, Python… le regex non cambiano.
2. Rendono ricerca e sostituzione del testo enormemente più potenti
3. Soddisfano pienamente il principio 80/20. Basta conoscerne il 20% per risolvere l'80% dei problemi.

Ho preparato una pagina di prova per testare le regex del tutorial. In alternativa è sempre possibile usare una IDE, praticamente tutte supportano le regular expressions.

Partiamo dalla [cornice]

La regex più semplice? Eccola:

bank

La quale cerca “bank”. Cambiamola leggermente, immaginiamo di voler cercare sia “bank” che “tank” nello stesso blocco di testo.

[bt]ank  // cerca sia bank che tank

La [cornice] rappresenta comunque 1 carattere. Stiamo ancora cercando una parola di 4 caratteri, ma il primo può essere “b” oppure “t”. I caratteri inclusi nelle parentesi [] sono legati da una relazione di tipo OR. La loro posizione è irrilevante, [tb]ank è semanticamente identico. Ecco altri esempi d’uso della [cornice]:

[abc]1              // trova a1, b1 o c1
[cba]1              // trova a1, b1 o c1
file[0123456789]    // trova file0,file1,file2 ... o file9
file[0-9]           // trova file0,file1,file2 ... o file9
[a-z]               // trova a, b, c oppure ... z

Avrai notato che abbiamo introdotto un nuovo operatore. Usando il carattere - definiamo un range. Il range ci permette di evitare costrutti assurdamente lunghi come questo: [abcdefghijklmnopqrstuvwyz]. E’ una scorciatoia.

Proseguiamo coi Quantificatori

Riprendiamo dall’esempio iniziale. Immaginiamo di voler trovare tank, bank, tanks, e banks. Potremmo provare in questo modo:

[bt]anks?

Abbiamo aggiunto il quantificatore ? che agisce sul carattere che si trova direttamente alla sua sinistra. Significa una occorrenza oppure nessuna, quindi nel nostro caso stiamo dicendo “cerca [bt]ank con una ’s’ finale o meno”. Un quantificatore può essere affiancato a qualunque carattere e addirittura a una [cornice]. Dai una occhiata a questi esempi:

[bt]anks         // trova banks o tanks
[bt]anks?        // trova bank, tank, banks oppure tanks
[bt]?ank         // trova bank, tank oppure ank
ab?c?            // trova a, ab, abc oppure ac

Riassumendo, quando usiamo un carattere senza quantificatore indichiamo che ne cerchiamo una singola occorrenza. Quando aggiungiamo un quantificatore cambia il numero di occorrenze che vogliamo trovare. Nella tabella seguente trovi l’elenco dei quantificatori disponibili:

<th>
  significato
</th>

<th>
  regex
</th>

<th>
  esempio
</th>

<td>
  zero o 1
</td>

<td>
  abc?
</td>

<td>
  ab, abc
</td>

<td>
  zero o più
</td>

<td>
  abc*
</td>

<td>
  ab,abc,abcc,abccc,abcccc,… etc
</td>

<td>
  uno o più
</td>

<td>
  abc+
</td>

<td>
  abc,abcc,abccc,abcccc,…etc
</td>

<td>
  esattamente n volte
</td>

<td>
  abc{2}
</td>

<td>
  abcc
</td>

<td>
  da n a m volte
</td>

<td>
  abc{2,3}
</td>

<td>
  abcc,abccc
</td>

Concludendo

Abbiamo appreso la sintassi base che ci consente di fare un pò di pratica. E’ una buona idea fare quale esperimento in una IDE oppure sulla pagina demo.

La seconda parte di questa guida è ora pubblicata.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 1. Ringrazio l’autore per il permesso accordatomi.

1. Da Python 2 a Python 3

   Python 3 è il futuro, ma Python 2 è attualmente la versione più usata al mondo. Ora finalmente la documentazione ufficiale è arricchita da una bella guida alle migliori strategie per supportare entrambe le versioni di Python.

2. Per quale motivo 400 persone si sono offerte volontarie per una viaggio di sola andata verso Marte?

Il numero Ottobre-Novembre 2010 del _Journal of Cosmology_ contiene uno speciale di 55 pagine intitolato “Missione Umana su Marte: Colonizzare il Pianeta Rosso”. Secondo gli scienziati una missione di sola andata destinata a colonizzare Marte sarebbe possibile entro 20 anni. Cosa ha spinto ben quattrocento lettori a offrirsi come volontari per la missione?

3. Il sorprendente effetto di un singolo Tweet sul Page Rank di Google

Google ha ammesso recentemente che i link provenienti dai social network sono segnali usati nella valutazione dell’importanza dei siti web. I ragazzi di SEOmoz (tra i migliori esperti SEO in circolazione) sono rimasti esterrefatti dagli effetti che un singolo tweet ha causato sul page rank della loro _Beginners Guide to SEO_.

4. Lettera aperta a un organizzatore di eventi

Per mestiere Luca Sartoni partecipa (come speaker, spettatore o organizzatore) a molte conferenze , seminari e workshops. In questa lettera elenca quelli che secondo lui sono i cinque errori commessi più spesso dagli organizzatori di eventi. E suggerisce come evitarli.

5. Come si fa WordPress?

A quanto pare WordPress, pur avendo una sede a San Francisco, è una realtà capillarmente distribuita. Gran parte dei dipendenti lavora da casa ed è disseminata per il mondo, coprendone quasi tutti i fusi orari. In questo articolo sul blog ufficiale dell’azienda Scott Berkun racconta come si svolge una giornata di lavoro in una azienda di questo tipo.

6. Come ospitare un intero sito (statico) su Amazon S3

Da qualche tempo Werner Vogels, CTO di Amazon, ospita il suo sito direttamente su S3, la potente piattaforma di _cloud storage_ di Amazon. Una soluzione di questo tipo offre diversi vantaggi, primo fra tutti la scalabilità. In questo articolo Vogels ci spiega come raggiungere lo stesso risultato.

7. Sono una Designer e ho lanciato la mia prima applicazione in 6 settimane

Tracy è una designer che non sa quasi nulla di programmazione. Ha una idea su un sito innovativo e tenta senza successo di ottenere un finanziamento che le consenta di assumere un programmatore esperto. Cosa fare? Tracy si rimbocca le maniche e in sei settimane riesce a lanciare una variante (semplificata) della sua idea originale. In Python/Django, ovviamente.

8. La Guida Definitiva al Design delle Pagine Facebook

Facebook ha aggiornato le Pagine Fan introducendo parecchie novità significative. In questo articolo Six Revisions ci spiega quali sono e come sfruttarle al meglio.

9. I filmati completi del Corso di Programmazione (Python) del MIT

Ventiquattro filmati completi, di ottima qualità, per imparare a programmare direttamente dai professori del famoso MIT di Boston. Il materiale è di qualità eccellente.

10. Il curriculum vitae di Leonardo Da Vinci

Prima di Mona Lisa, dell’Ultima Cena e dell’invenzione dell’elicottero anche a Leonardo Da Vinci è toccato scrivere il suo bel curriculum. Nel 1482, a trent’anni, Leonardo lo inviò a Ludovico il Moro, Duca di Milano. In questo splendido articolo possiamo vedere l’originale e leggerne la trascrizione. Perché? Per imparare un paio di trucchetti che potrebbero tornarci utili.

11. Processare il Linguaggio Naturale in Python

L’intero contenuto del libro _Natural Processing Language With Python_ in formato PDF, liberamente accessibile.

Queste sono solo alcune delle segnalazioni che giorno per giorno pubblico su Twitter. Se volete più notizie, spunti e link interessanti seguitemi anche su Twitter!

Come funziona

La registrazione è gratuita e comprende la fornitura di 12 crediti spendibili subito per pubblicare domande sul sito. Chi fornirà la risposta migliore si aggiudicherà il premio in denaro (2€, 5€, 10€, ecc.) messo in palio dall’autore della domanda. Le categorie disponibili in questo momento sono Grafica, Programmazione,  SEO & Marketing, CMS, Social Media, Fisco e Contabilità, Software, Hardware, Dominio + Hosting. Altre verranno aggiunte nel tempo.

Il modello di business

Avete letto bene. Su TuoGuru girano soldi! Esauriti i 12 crediti iniziali per porre domande dovrete acquistarne altri (oppure invitare amici sul sito). Al costo dei crediti dovrete poi aggiungere il premio da corrispondere nel caso qualcuno vi fornisca la risposta che cercate. Riassumendo:

1. Il sito incassa vendendo crediti.
2. Chi risponde ha la possibilità di guadagnare fornendo la risposta migliore.
3. Chi fa domande compra la possibilità di ottenere risposte veloci, precise e attendibili.

Di questi tempi potrebbe sembrare un controsenso pagare per ottenere risposte. Ci sono miriadi di forum e siti Q&A gratuiti. La scommessa di un servizio come questo è infatti la nicchia, ovvero scommettere su coloro che pur di proseguire il lavoro e ottenere rapidamente una risposta qualificata non hanno problemi a investire una cifra tutto sommato modesta.

La chiave del successo

In questi schemi il personaggio chiave è l’esperto, colui/colei che decide di investire il proprio tempo fornendo risposte di qualità sperando di guadagnarci qualcosa. Più risposte qualificate, rapide e attendibili arriveranno più è probabile che gli utenti decideranno di usare il servizio a pagamento. Rispondere alle domande è gratuito, consente di migliorare la propria fama (esiste un meccanismo di classifiche interne), può essere divertente e può dare una mano a far quadrare i conti a fine mese. Perché non provarci?

I primi passi

In due giorni dall’apertura al pubblico ci sono già più di 500 utenti registrati. Le domande cominciano circolare e, soprattutto, le riposte fioccano. Bei segnali positivi. Questi ragazzi ci stanno provando seriamente e stanno lavorando bene. Si meritano un grosso in bocca al lupo!

Il Programma

Il programma è ricco di argomenti interessanti. Per solleticare il tuo appetito (ci sono ancora posti disponibili) ti propongo una selezione degli interventi che personalmente attendo con grande curiosità:

• Google Ranking: novità e scoperte inedite su come Google classifica i risultati organici, alla luce delle ultime ricerche svolte da SEOmoz.org (Rand Fishkin)
• Comunicare On-line con i Video. Video marketing: i fattori che determinano il successo di un video online e la diffusione virale. Video Analytics: misurare l’impatto dei propri video e calcolare il ritorno dell’investimento (Paolo Zanzottera)
• Ranking e comportamento dell’utente: come perfezionare il ranking attraverso l’analisi di Click-Through e Bounce Rate (Marcus Tandler)
• Come video, news e immagini hanno influito sulle tradizionali tecniche di posizionamento. Come applicare delle strategie ad hoc per la Universal Search (Neils Dörje)
• Link building: Dieci strategie avanzate per una link popularity efficace (Marcus Tandler)
• Ottimizzazione del Tasso di Conversione: come trasformare un sito locale in un “Conversion Funnel”, tracciare i dati e migliorare il tasso di conversione (Rand Fishkin)

Per vedere l’elenco completo degli interventi consulta il programma ufficiale sul sito ufficiale.

Incontriamoci!

Ribadisco l’invito già fatto in passato. Se anche tu sarai presente fammelo sapere, magari organizziamo due chiacchiere davanti a un caffè o un aperitivo!

Estensioni di questo tipo esistono da tempo ma questa si distingue per un motivo importante. Nel suo annuncio Matt Cutts, responsabile Google per i motori di ricerca, afferma che i siti bloccati da Personal Blocklist (questo il nome dell’estensione) verranno registrati in un database. In futuro Google potrebbe escludere questi siti dai risultati organici delle ricerche:

One of the signals we’re exploring is explicit feedback from users. To that end, today we’re launching an early, experimental Chrome extension so people can block sites from their web search results. If installed, the extension also sends blocked site information to Google, and we will study the resulting feedback and explore using it as a potential ranking signal for our search results.

Un sito bloccato da migliaia di utenti potrebbe indurre Google a classificarlo come content farm ed escluderlo dai risultati delle ricerche. E’ probabile (e auspicabile!) che, almeno in una prima fase, questi siti saranno sottoposti a uno scrutinio accurato prima di venire depennati.

Web 2.0 all’ennesima potenza

Finora Google ha sempre dichiarato di puntare fermamente a una soluzione algoritmica al problema della classificazione dei siti web. Con l’annuncio di oggi pare aprirsi una crepa in questa filosofia. Per la prima volta gli utenti potrebbero avere la possibilità di partecipare in maniera attiva alla selezione qualitativa dei risultati proposti da un motore da ricerca.

Un sistema abusabile?

Probabilmente è presto per preoccuparsi di questo ma c’è da augurarsi, se mai ci si arriverà, che l’implementazione finale tenga ben conto del rischio di abusi. Una azienda con pochi scrupoli potrebbe pensare di investire quattrini sonanti in una campagna di discredito nei confronti di un concorrente. Certo non sarebbe semplice né economico, ma pur sempre fattibile.

Che ne pensate?

Questa mi pare una innovazione interessante sia dal punto di vista pratico-funzionale che ‘sociale’, passatemi il termine.  Voi cosa ne pensate?

Approfondimenti

• Annuncio della nuova Estensione per Google Chrome
• Pagina ufficiale di Personal Blocklist
• Dettagli sul funzionamento dell’estensione su Search Engine Roundtable

Se avete installato DropBox su ognuno dei vostri computer (un Mac a casa e un PC al lavoro per esempio) il risultato sarà quello di lavorare nel 

cloud mantenendo però copie locali, sincronizzate, dei vostri sorgenti. Potrete spostarvi da un computer all’altro e riprendere la scrittura del codice come se niente fosse. L’editor integrato è Mozilla Skywriter (ora Ace) e supporta parecchi linguaggi: C/C++, C#, Ruby, Python, PHP, HTML, JavaScript, Java.

Proprio l’altro giorno raccontando del progetto Orion Eclipse mi (e vi) chiedevo se il futuro del codice sorgente non sia online. SourceKit ci da la possibilità di provare subito “l’effetto che fa”, come diceva una vecchia pubblicità. Provare per credere!

Già dalla home page è evidente come in Google si siano ingegnati per offrire una

esperienza di ricerca del tutto simile a quella classica alla quale gli utenti sono abituati (verrebbe da dire condizionati) da tempo. L’integrazione è tale che basta un click per spostarsi dalla ricerca in Google Shopping a quella in Google Classico.

Il visitatore può ordinare o filtrare i risultati in base al prezzo, oppure può confrontare le offerte che i diversi commercianti propongono per lo stesso prodotto. E’ presente anche un carrello della spesa nel quale inserire i prodotti e le offerte più interessanti.

Cosa ci guadagna il commerciante?

Una volta compiuta la scelta l’utente viene indirizzato sul sito del commerciante. E’ dunque il commerciante stesso a realizzare direttamente la vendita**.**

Il servizio è gratuito e non sembra che Google sia interessata a provvigioni o voglia applicare tariffe per l’iscrizione al catalogo (verificherò con calma nelle prossime ore). Un dettaglio da considerare con attenzione: il visitatore che arriva sul nostro sito via Google Shopping è fortemente motivato all’acquisto: conosce il prezzo e ha scelto di sua iniziativa di venire a trovarci. Tocca a noi giocarcela bene offrendogli una ottima esperienza di acquisto!

Come ci guadagna Google?

Innanzi tutto grazie alla integrazione (già annunciata) con AdWords. Le confezioni dei prodotti appariranno anche nella ricerca classica, integrate negli annunci AdWords. C’è poi Checkout, il servizio Google per i pagamenti online. Non è un caso che il primo filtro che appare in Google Shopping sia proprio la selezione dei soli prodotti acquistabili via Checkout.

C’è infine il fattore strategico. Se il servizio decollerà Google diventerà uno strumento indispensabile per mettere in contatto venditori e acquirenti. In futuro sarà molto difficile rinunciarvi, qualunque saranno le condizioni o i servizi (a pagamento?) che Google vorrà veicolare via Google Shopping.

Cominciare subito

Benché il servizio non sia ancora aperto al pubblico è già possibile registrarsi a Google Merchant Center, il sito per commercianti sul quale registrare i propri prodotti. Il sistema è basato su feeds ed è piuttosto sofisticato (ma non troppo complicato), il che testimonia l’interesse di Google per l’intero progetto.

Gli eBooks di Stack Overflow

Recentemente Greg Hewkill ha annunciato la creazione di uno script open source che genera un eBook per ognuno dei 20 tag più popolari di Stack Overflow. Ogni libro contiene le domande (e risposte) più votate nella sua categoria. Il risultato è una vera e propria collana Stack Overflow che propone il concentrato dei migliori contenuti del sito. Basta scorrere i titoli (tag) per rendersi conto che ce n’è davvero per tutti i gusti. Ecco una lista parziale:

• JAVA (26M)
• C# (24M), C++ (21M), C (11M)
• NET (21M)
• PYTHON (20M), DJANGO (1.6M)
• JAVASCRIPT (15M)
• PHP (9.6M)
• IPHONE (7.3M)
• HTML (6.0M), HTML 5 (3.0M)
• CSS (5.7M)
• JQUERY (5.5M)
• ASP.NET (4.8M)
• DATABASE (4.8M)
• RUBY (3.1M), RUBY ON RAILS (1.9M)
• ANDROID (2.7M)
• MY SQL (2.5M), ORACLE (662K), SQL SERVER (2.8M), SQL (5.1M)
• AJAX (2.1M)
• COCOA (1.5M), OBJECTIVE-C (3.1M)
• VB.NET (1.5M)
• SILVERLIGHT (1.1M)
• FLASH (509K)

Alcuni sono di dimensioni notevoli il che ne fa ideali letture da divano! Il formato usato per confezionare gli eBook è Mobipocket, compatibile con [Stack Overflow è la risorsa per programmatori più famosa e apprezzata della Rete. Purtroppo domande e risposte pubblicate sul sito si succedono a un ritmo tale che è impossibile seguire gli aggiornamenti in tempo reale. Per questo motivo la gran parte degli utenti (sottoscritto incluso!) ricorre a Stack Overflow solo al momento del bisogno, quando è necessario trovare in fretta la soluzione a un problema critico. E’ un peccato perchè Stack Overflow è una vera minera di informazioni preziose e  meriterebbe maggiore attenzione…

Gli eBooks di Stack Overflow

Recentemente Greg Hewkill ha annunciato la creazione di uno script open source che genera un eBook per ognuno dei 20 tag più popolari di Stack Overflow. Ogni libro contiene le domande (e risposte) più votate nella sua categoria. Il risultato è una vera e propria collana Stack Overflow che propone il concentrato dei migliori contenuti del sito. Basta scorrere i titoli (tag) per rendersi conto che ce n’è davvero per tutti i gusti. Ecco una lista parziale:

• JAVA (26M)
• C# (24M), C++ (21M), C (11M)
• NET (21M)
• PYTHON (20M), DJANGO (1.6M)
• JAVASCRIPT (15M)
• PHP (9.6M)
• IPHONE (7.3M)
• HTML (6.0M), HTML 5 (3.0M)
• CSS (5.7M)
• JQUERY (5.5M)
• ASP.NET (4.8M)
• DATABASE (4.8M)
• RUBY (3.1M), RUBY ON RAILS (1.9M)
• ANDROID (2.7M)
• MY SQL (2.5M), ORACLE (662K), SQL SERVER (2.8M), SQL (5.1M)
• AJAX (2.1M)
• COCOA (1.5M), OBJECTIVE-C (3.1M)
• VB.NET (1.5M)
• SILVERLIGHT (1.1M)
• FLASH (509K)

Alcuni sono di dimensioni notevoli il che ne fa ideali letture da divano! Il formato usato per confezionare gli eBook è Mobipocket, compatibile con]7 e credo con altri lettori di eBook. Ricordo che è possibile leggere i libri per Kindle con l’applicazione gratuita disponibile per PC, Mac, [Stack Overflow è la risorsa per programmatori più famosa e apprezzata della Rete. Purtroppo domande e risposte pubblicate sul sito si succedono a un ritmo tale che è impossibile seguire gli aggiornamenti in tempo reale. Per questo motivo la gran parte degli utenti (sottoscritto incluso!) ricorre a Stack Overflow solo al momento del bisogno, quando è necessario trovare in fretta la soluzione a un problema critico. E’ un peccato perchè Stack Overflow è una vera minera di informazioni preziose e  meriterebbe maggiore attenzione…

Gli eBooks di Stack Overflow

Recentemente Greg Hewkill ha annunciato la creazione di uno script open source che genera un eBook per ognuno dei 20 tag più popolari di Stack Overflow. Ogni libro contiene le domande (e risposte) più votate nella sua categoria. Il risultato è una vera e propria collana Stack Overflow che propone il concentrato dei migliori contenuti del sito. Basta scorrere i titoli (tag) per rendersi conto che ce n’è davvero per tutti i gusti. Ecco una lista parziale:

• JAVA (26M)
• C# (24M), C++ (21M), C (11M)
• NET (21M)
• PYTHON (20M), DJANGO (1.6M)
• JAVASCRIPT (15M)
• PHP (9.6M)
• IPHONE (7.3M)
• HTML (6.0M), HTML 5 (3.0M)
• CSS (5.7M)
• JQUERY (5.5M)
• ASP.NET (4.8M)
• DATABASE (4.8M)
• RUBY (3.1M), RUBY ON RAILS (1.9M)
• ANDROID (2.7M)
• MY SQL (2.5M), ORACLE (662K), SQL SERVER (2.8M), SQL (5.1M)
• AJAX (2.1M)
• COCOA (1.5M), OBJECTIVE-C (3.1M)
• VB.NET (1.5M)
• SILVERLIGHT (1.1M)
• FLASH (509K)

Alcuni sono di dimensioni notevoli il che ne fa ideali letture da divano! Il formato usato per confezionare gli eBook è Mobipocket, compatibile con [Stack Overflow è la risorsa per programmatori più famosa e apprezzata della Rete. Purtroppo domande e risposte pubblicate sul sito si succedono a un ritmo tale che è impossibile seguire gli aggiornamenti in tempo reale. Per questo motivo la gran parte degli utenti (sottoscritto incluso!) ricorre a Stack Overflow solo al momento del bisogno, quando è necessario trovare in fretta la soluzione a un problema critico. E’ un peccato perchè Stack Overflow è una vera minera di informazioni preziose e  meriterebbe maggiore attenzione…

Gli eBooks di Stack Overflow

Recentemente Greg Hewkill ha annunciato la creazione di uno script open source che genera un eBook per ognuno dei 20 tag più popolari di Stack Overflow. Ogni libro contiene le domande (e risposte) più votate nella sua categoria. Il risultato è una vera e propria collana Stack Overflow che propone il concentrato dei migliori contenuti del sito. Basta scorrere i titoli (tag) per rendersi conto che ce n’è davvero per tutti i gusti. Ecco una lista parziale:

• JAVA (26M)
• C# (24M), C++ (21M), C (11M)
• NET (21M)
• PYTHON (20M), DJANGO (1.6M)
• JAVASCRIPT (15M)
• PHP (9.6M)
• IPHONE (7.3M)
• HTML (6.0M), HTML 5 (3.0M)
• CSS (5.7M)
• JQUERY (5.5M)
• ASP.NET (4.8M)
• DATABASE (4.8M)
• RUBY (3.1M), RUBY ON RAILS (1.9M)
• ANDROID (2.7M)
• MY SQL (2.5M), ORACLE (662K), SQL SERVER (2.8M), SQL (5.1M)
• AJAX (2.1M)
• COCOA (1.5M), OBJECTIVE-C (3.1M)
• VB.NET (1.5M)
• SILVERLIGHT (1.1M)
• FLASH (509K)

Alcuni sono di dimensioni notevoli il che ne fa ideali letture da divano! Il formato usato per confezionare gli eBook è Mobipocket, compatibile con]7 e credo con altri lettori di eBook. Ricordo che è possibile leggere i libri per Kindle con l’applicazione gratuita disponibile per PC, Mac,]10 e Android.

Buona lettura!

Il Progetto Orion

Semplici editor di codice sorgente sono disponibili online già da tempo, ma progetti come Orion portano il concetto di programmazione online a un livello superiore. Annunciato pochi giorni fa dal team di sviluppo di Eclipse, una IDE Open Source molto diffusa e apprezzata, il progetto Orion è qualcosa di nuovo:

E’ una piattaforma di sviluppo aperta focalizzata totalmente allo sviluppo per il web, dentro il web. I tools sono scritti in JavaScript e girano nel browser. A differenza di altri tentativi di realizzare strumenti di sviluppo integrati nel browser, Orion non è una IDE che gira in una singola scheda del browser. I links funzionano e possono essere condivisi. Puoi aprire files in schede diverse e grande cura è stata messa nel fornire una ottima web experience durante lo sviluppo del codice

  <p class="wp-caption-text">
    Codice JavaScript sviluppato direttamente in Google Chrome - Progetto Orion/Eclipse
  </p>
</div>

<p>
  Orion supporta JavaScript e presto funzionerà anche con PHP, HTML, CSS e Java.
</p>

<h2>
  Cloud9 e gli altri
</h2>

<p>
  <img class="alignleft" title="Cloud9 IDE" src="images/2011/01/cloud9ide.png?resize=147%2C150" alt="Cloud9 IDE" data-recalc-dims="1" />Anche <strong>Mozilla</strong> lavora da tempo (2008) a qualcosa di simile. <a href="http://mozillalabs.com/skywriter/">Skywriter</a>, semplice editor online ora integrato in <a href="http://ace.ajax.org/">Ace</a>, è alla base della piattaforma <a style="font-weight: bold;" href="http://cloud9ide.com/">Cloud9 IDE</a>. Attualmente in beta, Cloud9 è una IDE JavaScript integrata in Google Chrome che promette prestazioni uguali a quelle offerte da editor e IDE tradizionali, integrazione tra codice sorgente locale e remoto, debugging e deployment integrati.
</p>

<p>
  Altro brillante esempio è <strong><a href="http://www.coderun.com/">CodeRun</a></strong>, IDE online già funzionante e gratuita dedicata soprattutto a sviluppatori ASP.NET, Silverlight e WPF. Il mondo IDE insomma è in gran fermento.
</p>

<h2>
  Vantaggi e svantaggi di sviluppare nel cloud
</h2>

<p>
  Immaginate un <a href="http://docs.google.com/">Google Documents</a> per programmatori. Oggi possiamo creare online fogli di calcolo, testi e presentazioni; domani potremo sviluppare i nostri programmi nel browser. Ma quali sono i vantaggi e gli svantaggi di affidarsi a un ambiente di sviluppo online? Gli stessi offerti da un ambiente di produttività come Google Documents.
</p>

<h3>
  Accessibilità
</h3>

<p>
  Possiamo accedere al nostro ambiente di lavoro da qualunque località nel mondo. Bastano un accesso internet e un browser per metterci al lavoro. Siamo a Bangkok e abbiamo un paio di ore a disposizione? Entriamo in un internet cafe e pochi minuti dopo stiamo scrivendo codice o revisionando il lavoro dei colleghi. Il che ci porta al prossimo punto.
</p>

<h3>
  Collaborazione e condivisione semplificate
</h3>

<p>
  Nei progetti più importanti è spesso necessario installare strumenti di gestione e controllo dei team di sviluppo. Il codice sorgente memorizzato su un server remoto e accessibile a chiunque rende collaborazione e condivisione del codice più semplice. Tutte le cloud IDE promettono il supporto per team di sviluppo.
</p>

<h3>
  Indipendenza dalla piattaforma hardware
</h3>

<p>
  Con le cloud IDE scriviamo codice in un web browser. Compilazione, linking e debugging sono processi svolti su una macchina remota che (si suppone) offrirà prestazioni adeguate al compito. Trovarsi momentaneamente su un computer poco performante non sarà un problema. Sviluppare su computers diversi (Mac a casa e PC in ufficio, per esempio) non comporterà differenze sostanziali.
</p>

<h3>
  Riservatezza
</h3>

<p>
  Il nostro codice sarà memorizzato su un dispositivo sul quale non potremo esercitare un controllo assoluto. Difficilmente avremo garanzia di totale riservatezza. Applicazioni particolarmente delicate non potranno probabilmente essere sviluppate <em>sulle nuovole </em>anche se servizi di successo come <strong><a href="https://github.com/">GitHub</a> </strong>offrono supporto a progetti open source e privati garantendo a questi ultimi la riservatezza necessaria.
</p>

<h3>
  Sicurezza
</h3>

<p>
  Che succede se il mio codice sorgente viene perduto in seguito a un guasto hardware del sistema remoto che lo ospita? L&#8217;affidabilità è senz&#8217;altro un aspetto delicato e costituisce uno dei deterrenti all&#8217;adozione dei sistemi di cloud computing in generale. Affidare i nostri codici a terzi non ci impedirebbe di conservarne copie locali. Come già successo per i sistemi di <a href="http://it.wikipedia.org/wiki/Cloud-storage">cloud storage</a>, i servizi di cloud development dovranno offrire elevati standard di sicurezza e affidabilità.
</p>

<h2>
  Conclusioni
</h2>

<p>
  Lo sviluppo di applicazioni <em>sulle nuvole</em> è senz&#8217;altro una prospettiva affascinante che presto sarà di attualità. Non sono poche le perplessità degli sviluppatori, soprattutto negli ambienti <em>enterprise</em> o nei settori nei quali la riservatezza è un elemento determinante. Le applicazioni web saranno le prime implementate con queste tecnologie, per le altre bisognerà probabilmente attendere a lungo.
</p>

<h4>
  Approfondimenti
</h4>

<ul>
  <li>
    <a href="http://dev.eclipse.org/blogs/mike/2011/01/11/introducing-orion/">Introducing Orion</a>, di Mike Milinkovich
  </li>
  <li>
    <a href="http://borisoneclipse.blogspot.com/2011/01/orion.html">Orion</a>, di Boris Bukowski
  </li>
  <li>
    <a href="http://jaxenter.com/eclipse-orion-the-new-ide-paradigm-33431.html">Eclipse Orion: The New IDE Paradigm</a>, intervista a B. Bukowski
  </li>
  <li>
    <a href="http://www.i-programmer.info/news/90-tools/1872-mozilla-and-eclipse-take-programming-into-the-cloud.html">Mozilla and Eclipse take programming into the cloud</a>, di Mike James
  </li>
  <li>
    <a href="http://dotnet.dzone.com/articles/online-ides-%E2%80%93-perspectives">Online IDEs – perspectives?</a> Di Den Delimarsky
  </li>
</ul>

Cosa è Humans.txt?

Un semplice file di testo che contiene informazioni sulle persone che hanno contribuito alla costruzione del sito. Il file non è intrusivo e non causa decadimento delle prestazioni perché collocato all’esterno della gerarchia del sito vero e proprio. Viene salvato nella web root, proprio là dove di solito risiede il robots.txt. Se consentito dal committente si potrebbe aggiungere un riferimento nella homepage:

Nel file si può indicare più di un nome: il programmatore, il designer, il copywriter, il web master, il SEO/SEM, eventuali dediche. Le possibilità sono tante quante sono le persone che normalmente intervengono nella creazione di un sito. Potremmo immaginare humans.txt come l’equivalente della sigla di una trasmissione televisiva, oppure di un film.

Alla ricerca di uno standard

Gli autori dell’iniziativa propongono delle linee guida per la compilazione del file humans.txt e si dicono pronti ad accettare suggerimenti da chiunque. L’idea di standardizzare il contenuto del file è senz’altro valida perché consentirebbe, tra le altre cose, la creazione di tools di ricerca e certificazione. Pensate per esempio a una estensione del browser che consenta di vedere i credits del sito che stiamo visitando. Ci sono parecchie possibilità di applicazione da esplorare.

Una iniziativa superflua?

Lo standard HTML contempla già un tag Meta Name per l’autore. Si tratta di un elemento opzionale e non indicizzato dai motori di ricerca. Il problema con questo tag è che il committente potrebbe non gradirlo. Lo standard prevede di indicare un solo autore mentre, come abbiamo visto, in humans.txt possiamo indicare più persone. Le due soluzioni possono coesistere, dando spazio a soluzioni interessanti: un’agenzia potrebbe inserire il proprio nome nel meta tag ed elencare i membri del team in humans.txt. La discussione comunque è piuttosto accesa. C’è chi ritiene superflua l’iniziativa. Ci sono i soliti complottisti che vedono dietro a tutto questo chissà quale oscura manovra a fin di lucro e c’è infine chi ci vuol credere davvero sostenendo i ragazzi spagnoli che hanno messo in piedi il progetto.

Comincia subito

Niente impedisce di aderire all’iniziativa già da ora. Deposita il tuo humans.txt nella root del tuo sito e sei a bordo. E’ anche possibile inviare il proprio file humans.txt agli autori dell’iniziativa i quali sostengono di voler compilare una lista globale che, stranamente, al momento non è consultabile. Ho chiesto loro come mai. La riposta è stata we’re looking to create something “different” to show humans. Qualcosa bolle in pentola.

Il programma

Il programma prevede le conferenze dei Big Speakers nella prima giornata e gli approfondimenti tecnici (E-Commerce o Turismo) nella seconda. Per quest’ultima è già disponibile l’elenco degli argomenti trattati mentre per la prima bisognerà attendere ancora qualche giorno. Qui riporto il programma della sessione E-Commerce, quella a cui parteciperò io:

• Introduzione agli strumenti per la promozione online
• E-commerce e diritto
• E-commerce con eBay e altri marketplaces
• Social Networks & Web Analytics 2.0
• Case History Keyword Advertising
• Intervista/Testimonianza
• Case History e-mail marketing
• Case history SEO da “oltreoceano”
• Strategie SEO e SEM

Incontriamoci!

Questi eventi in genere sono ottime occasioni per fare nuove conoscenze e scambiarsi opinioni ed esperienze. Se qualcuno dei lettori di questo sito prevede di partecipare me lo faccia sapere, magari organizziamo due chiacchiere davanti a un caffè o un aperitivo!

Potrebbe sembrare il contrario, ma vi assicuro che non sono coinvolto in alcun modo nella organizzazione o promozione di questo evento.

Nel web marketing il conversion rate è la percentuale di visitatori unici che hanno effettuato l’operazione desiderata visitando il sito. L’azione desiderata potrebbe essere condurre vendite, effettuare acquisti, osservare una pagina chiave del sito, o altre azioni misurabili (fonte: wikipedia)

E’ possibile aumentare del 250% il conversione rate grazie a una sola, banale modifica al sito? I signori di Kajabi sostengono di esserci riusciti nel corso di un esperimento durato una settimana. La loro home page è organizzata in modo da convogliare l’attenzione del visitatore su un unico, grande pulsante che invita il visitatore a consultare le tariffe del servizio offerto in abbonamento. Lasciando invariato il resto della pagina hanno ritoccato il contenuto del pulsante, registrando poi il numero di click ottenuti in un dato periodo di tempo. Il ciclo è stato ripetuto quattro volte, ogni volta con un testo diverso. Ecco come è andata:

L’importanza del giusto messaggio

Un pò di prudenza non guasta

Una evoluzione continua

I piccoli problemi e le nuove incompatibilità che inevitabilmente accompagnano ogni aggiornamento dei browser esistenti, nonché le uscite di quelli nuovi (Google Chrome su tutti) costringono spesso a rivedere fogli di stile e codice JavaScript. Così nel tempo altri programmatori  hanno dato il loro contribuito proponendo variazioni e aggiornamenti al tema originale. Ci sono poi le nuove tecnologie che si affacciano sulla scena; una delle revisoni più famose del Eric Mayer Reset è infatti l’HTML5 Reset Stylesheet.

Eric Meyer Reset versione 2011

Ed ecco che a sopresa lo stesso Meyer torna sulla scena proponendo l’ultima incarnazione del suo CSS Reset. Questo aggiornamento prende spunto dall’originale ma tiene conto anche del lavoro svolto nel frattempo dalla comunità, a partire proprio dal HTML5 Reset. Ecco il nuovo codice:

/* http://meyerweb.com/eric/tools/css/reset/
v2.0b1 | 201101
NOTE: WORK IN PROGRESS
USE WITH CAUTION AND TEST WITH ABANDON */

html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td,
article, aside, canvas, details, figcaption, figure,
footer, header, hgroup, menu, nav, section, summary,
time, mark, audio, video {
    margin: 0;
    padding: 0;
    border: 0;
    outline: 0;
    font-size: 100%;
    font: inherit;
    vertical-align: baseline;
}
/* HTML5 display-role reset for older browsers */
article, aside, details, figcaption, figure,
footer, header, hgroup, menu, nav, section {
    display: block;
}
body {
    line-height: 1;
}
ol, ul {
    list-style: none;
}
blockquote, q {
    quotes: none;
}
blockquote:before, blockquote:after,
q:before, q:after {
    content: '';
    content: none;
}

/* remember to define visible focus styles!
:focus {
    outline: ?????;
} */

/* remember to highlight inserts somehow! */
ins {
    text-decoration: none;
}
del {
    text-decoration: line-through;
}

table {
    border-collapse: collapse;
    border-spacing: 0;
}

Come annotato a caratteri cubitali nelle note iniziali ci troviamo di fronte a un lavoro non ancora definitivo. Sarà mia cura segnalare eventuali aggiornamenti, tuttavia una prima occhiata al codice fa pensare che questa prima stesura sia già valida.

Ne vale la pena?

C’è un discussione in corso da tempo tra chi sostiene che tutto sommato il CSS Reset non sia necessario e chi, al contrario, lo difende a spada stratta. Non risolve certo tutti i problemi di compatibilità tra browsers ma senz’altro CSS Reset contribuisce a ridurne sensibilmente il numero. Per approfondire l’argomento puoi cominciare dando una occhiata a Should You Reset Your CSS? (Six Revisions) e leggendo le opinioni degli utenti di Stack Overflow.

Non solo web e scripting

TIOBE sottolinea come in questi anni Python sia diventato il linguaggio standard per lo scripting, sostituendo di fatto Perl. Da questo ambito tutto sommato ristretto negli ultimi anni Python si è diffuso in molti altri campi, primo fra tutti il web, dove ha riscosso grande successo anche grazie al framework Django. Python è facile da imparare e molte università lo stanno adottando come linguaggio principale per l’insegnamento della programmazione. Tra i grandi nomi che sviluppano in Python ricordo Google, YouTube, il gioco multiplayer EVE Online, la NASA.

Il TIOBE Index come strumento strategico

Il TIOBE Programming Community index è un indicatore annuale della popolarità dei linguaggi di programmazione. La classifica è calcolata tenendo conto anche dei giudizi espressi da ingegneri  e sviluppatori di chiara fama, oltre che tracciando i risultati di corsi di addestramento tenuti in tutto il mondo. I risultati forniti dai motori di ricerca più importanti (Google, MSN, Yahoo!, Wikipedia e YouTube) vengono a loro volta inclusi nell’elaborazione della classifica.

TIOBE non è un indice che tenta di individuare il migliore linguaggio di programmazione, serve piuttosto a indicare quali sono le tendenze in corso a livello planetario. Si tratta di una valida risorsa per verificare l’attualità delle proprie competenze e per pianificare strategicamente i prossimi linguaggi di programmazione su cui investire. Come spunto di riflessione consiglio caldamente la lettura del celebre Paradosso di Python, formulato da Paul Graham nell’ormai lontano 2004. Forse i tempi stanno cambiando?

L’ultimo decennio: chi sale e chi scende

<p class="wp-caption-text">
  Andamento dell'indice TIOBE nell'ultimo decennio (2000-2010)
</p>

HTML5 in rapida diffusione

Eppure ci sono tante buone ragioni per non ricorrere a Flash:

1. Non è sicuro. Probabilmente Flash è l’unico prodotto che fa concorrenza a Microsoft Windows in quanto a numero di security fixes. Non per niente è stato definito il nuovo Windows Vista
2. E’ una tecnologia obsoleta, che si affida pesantemente ai plugin di terze parti (vedi alla voce sicurezza)
3. Rende lenta l’apertura delle pagine web, a meno che non si intervenga con ottimizzazioni ad-hoc
4. Consuma molta, troppa memoria
5. Richiede un forte impegno della CPU
6. Sui dispositivi portatili consuma velocemente la batteria
7. Non è supportato sui dispositivi iOS/Apple (iPhone, iPad)
8. Gira comunque male su buona parte degli altri dispositivi portatili, SmartPhones soprattutto
9. Ha seri problemi di compatibilità e prestazioni su piattaforme Mac/OSX
10. Molti utenti e (soprattutto) aziende bloccano Flash sui loro browsers proprio a causa dei problemi di sicurezza, stabilità e prestazioni
11. I contenuti Flash non sono facili da archiviare. Gli utenti medi hanno grosse difficoltà a salvare copie locali delle pagine. I servizi tipo Internet Archive non riescono a memorizzare il sito
12. Flash è il nemico numero uno dei motori di ricerca. Google, Bing e gli altri hanno da sempre grosse difficoltà ad indicizzarne i contenuti
13. Flash rende problematica, quando non impossibile, l’ottimizzazione ai fini del posizionamento sui motori di ricerca (SEO)
14. E’ un sistema proprietario chiuso

E’ vero che ricorrendo a ottimizzazioni e tools dedicati alcune (poche) di queste limitazioni possono essere aggirate. Le prossime release di Flash promettono sviluppi interessanti, tra i quali ottimizzazioni per i dispositivi mobili e riduzione del peso dell’intera infrastruttura.

Considera le alternative

Non sono necessarie soluzioni esoteriche. Troppo spesso si ricorre a Flash per produrre effetti, transizioni e animazioni realizzabili anche con strumenti consolidati, leggeri e SEO-friendly quali JavaScript, HTML e CSS. In una parola, AJAX. Cose ormai scontate. O forse no, a giudicare da quel che ancora oggi si pubblica in rete. A ben guardare la battaglia tra Apple e Adobe, quella culminata con la [E’ incredibile la quantità di siti che ancora oggi vengono sviluppati con Flash. Il fenomeno colpisce soprattutto i siti-vetrina: negozi, attività commerciali, ristoranti, artigiani. Basta farsi un giro sui siti di venditori di mobili, per esempio, per godersi il trionfo della ‘multimedia platform‘ di Adobe. Bisogna prenderne atto: nel 2011 migliaia di aziende italiane di ogni dimensione affidano la loro identità web ad Adobe Flash. Consulenti e agenzie continuano a produrre siti con tecnologie assimilate anni fa. Reticenti all’aggiornamento delle proprie competenze, si accontentano del loro confortante orticello che, tutto sommato, assicura lo stipendio.

Eppure ci sono tante buone ragioni per non ricorrere a Flash:

1. Non è sicuro. Probabilmente Flash è l’unico prodotto che fa concorrenza a Microsoft Windows in quanto a numero di security fixes. Non per niente è stato definito il nuovo Windows Vista
2. E’ una tecnologia obsoleta, che si affida pesantemente ai plugin di terze parti (vedi alla voce sicurezza)
3. Rende lenta l’apertura delle pagine web, a meno che non si intervenga con ottimizzazioni ad-hoc
4. Consuma molta, troppa memoria
5. Richiede un forte impegno della CPU
6. Sui dispositivi portatili consuma velocemente la batteria
7. Non è supportato sui dispositivi iOS/Apple (iPhone, iPad)
8. Gira comunque male su buona parte degli altri dispositivi portatili, SmartPhones soprattutto
9. Ha seri problemi di compatibilità e prestazioni su piattaforme Mac/OSX
10. Molti utenti e (soprattutto) aziende bloccano Flash sui loro browsers proprio a causa dei problemi di sicurezza, stabilità e prestazioni
11. I contenuti Flash non sono facili da archiviare. Gli utenti medi hanno grosse difficoltà a salvare copie locali delle pagine. I servizi tipo Internet Archive non riescono a memorizzare il sito
12. Flash è il nemico numero uno dei motori di ricerca. Google, Bing e gli altri hanno da sempre grosse difficoltà ad indicizzarne i contenuti
13. Flash rende problematica, quando non impossibile, l’ottimizzazione ai fini del posizionamento sui motori di ricerca (SEO)
14. E’ un sistema proprietario chiuso

E’ vero che ricorrendo a ottimizzazioni e tools dedicati alcune (poche) di queste limitazioni possono essere aggirate. Le prossime release di Flash promettono sviluppi interessanti, tra i quali ottimizzazioni per i dispositivi mobili e riduzione del peso dell’intera infrastruttura.

Considera le alternative

Non sono necessarie soluzioni esoteriche. Troppo spesso si ricorre a Flash per produrre effetti, transizioni e animazioni realizzabili anche con strumenti consolidati, leggeri e SEO-friendly quali JavaScript, HTML e CSS. In una parola, AJAX. Cose ormai scontate. O forse no, a giudicare da quel che ancora oggi si pubblica in rete. A ben guardare la battaglia tra Apple e Adobe, quella culminata con la]5 con la quale Steve Jobs in persona spiegava i motivi della rinuncia di Apple alla tecnologia Flash, è cosa recente.

Investire nel futuro

Le versioni più aggiornate dei browsers moderni (Firefox, Chorme, Safari, Opera e l’ormai imminente Internet Explorer 9) supportano ampiamente i nuovi standard HTML5 e CSS3. C’è chi ritiene che la loro certificazione sia troppo lontana e chi al contrario li ha adottati con entusiasmo. Una cosa è certa:  questi sono gli standard del futuro. La rete si sta preparando da tempo ed è ricca di risorse e demo interessanti:

• The Wilderness Downtown, splendida demo delle capacità di HTML5
• 10 Cool and Useful HTML 5 Tutorials
• 23 Essential HTML 5 Resources
• HTML5 Demos and Examples
• HTML5 Gallery

Da un punto di vista professionale vale senz’altro la pena investire fin da ora tempo e risorse nello studio di HTML5 e CSS3. L’avvento di Internet Explorer 9 aumenterà rapidamente il numero di navigatori HTML5-enabled; tanto che l’implementazione di siti di massa con queste tecnologie sarà possibile ben prima di quanto non si immagini.

Quali sono finora i linguaggi più gettonati?

1. Python (14.5%)
2. Ruby (13.8%)
3. Node.js (9.53%)
4. ECMAScript (JavaScript, ActionScript) (8.15%)
5. Scala (8.01%)

Python al momento si gode il primo posto anche se Ruby gli soffia sul collo e non sembra intenzionato a mollare l’osso. Al terzo posto, distanziato, l’interessantissimo progetto Node.js. Curiosa la scelta di includerlo nella selezione dato che non è un linguaggio di programmazione in senso stretto. JavaScript si piazza appena fuori dal podio mentre al quinto posto troviamo il primo dei new kids on the block, Scala.

Linguaggi script alla ribalta

E’ presto per trarre conclusioni (il questionario è online da pochi giorni e il sondaggio è ancora in corso) ma balza all’occhio come nelle prime quattro posizioni ci siano linguaggi script non compilati, a conferma di quella che sembra essere la tendenza degli ultimi anni, almeno nel contesto delle startup web e dei giovani programmatori web-oriented che costituisce in buona parte il pubblico di riferimento di un sito come ReadWriteWeb.

JavaScript è più importante di quanto si pensi

Uniti, Node.js e JavaScript balzano in vetta alla classifica. Il linguaggio JavaScript è sottovalutato da molti sviluppatori che si limitano a incollare brevi snippets per la manipolazione del DOM o la convalida di campi di input, ma le esigenze di interattività e reattività indurranno a spostare  l’implementazione dal server al client rendendo la conoscenza approfondita del linguaggio JavaScript sempre più determinante.

Presto dedicherò una serie di articoli a Python e proporrò alcuni approfondimenti su JavaScript. Rimani sintonizzato!

Ci sono poi certi sistemi di web mail (quello di Libero, per non far nomi) che semplicemente non sono capaci di riprodurre correttamente un link o se lo fanno non attivano il link per ragioni di sicurezza, lasciando così al destinatario della mail il compito di copiare e incollare l’intera URL nel browser. Operazione non sempre banale per l’utente medio, soprattutto quando (guarda caso!) il testo da copiare e incollare è lunghissimo.

Si potrebbe risolvere banalmente ricorrendo agli anchor tag HTML ma nel mio caso questa strada non è praticabile: i messaggi devono essere in puro testo. Non solo, questa soluzione non risolverebbe comunque il problema dei web mail client che non si fidano dei miei messaggi. Creare a priori URL brevi non è una opzione per ragioni di legacy (il sito non l’ho creato io!). Come fare allora?

Chiedere aiuto a un servizio URL Shortener

Gli URL shortener sono servizi molto usati in ambito social networking e non solo. Data una certa URL di qualunque lunghezza ne restituiscono una equivalente molto più breve. Pioniere in questo campo è stato TinyURL ma oggigiorno il servizio più diffuso e conosciuto è senz’altro Bit.ly, il quale ha l’indubbio vantaggio di offrire una REST API ricca, robusta e ben documentata. Questa libreria gratuita consente ai programmatori indipendenti (noi) l’implementazione di servizi di URL shortening nelle proprie applicazioni.

Ecco dunque ShortenUrl, una semplice funzione ASP.NET che restituisce una URL breve a partire da una URL di qualunque lunghezza passata come parametro. Nel caso la chiamata alla API fallisca la funzione restituirà semplicemente una stringa vuota.

La gran parte del lavoro è fatto da una sola linea di codice (ok, avrei potuto suddividerla in due o tre linee per amor di chiarezza, te lo concedo). La richiesta REST al servizio è eseguita da una istanza della classe HttpWebRequest. Il metodo Shorten può restituire risultati in formato JSON, XML o puro testo. Per semplicità ho scelto il formato testo. A seconda delle necessità potresti ricorrere al bellissimo formato JSON o al logorroico XML,  la documentazione ufficiale contiene esempi molto chiari anche per questi formati.

Se non disponi di un account Bit.ly dovrai registrarti (è gratis). Una volta creato l’account potrai recuperare facilmente la tua API Key personale, indispensabile per poter effettuare chiamate ai metodi della libreria.

Today, we are unveiling significant language and framework enhancements in C# and Visual Basic that enable developers to harness asynchrony, letting them retain the control flow from their synchronous code while developing responsive user interfaces and scalable web applications with greater ease.   This CTP delivers a lightweight asynchronous development experience as close to the standard synchronous paradigms as possible, while providing an easy on-ramp to the world of concurrency

Lo stesso Somasegar riconosce che finora sviluppare applicazioni asincrone complesse con la piattaforma .NET non è stato facile. Tempo fa l’ho sperimentato in prima persona. Lavoravo su Amica Prodigy Backup, una applicazione di backup remoto.

Il programma invia files di grandi dimensioni al servizio di cloud storage S3 aggiornando l’interfaccia utente con lo stato del trasferimento e consentendo nel frattempo di operare liberamente con l’interfaccia. Devo ammettere che si è trattata di una sfida molto accattivante. Lavoravo per la prima volta su sistemi cloud e c’era molto da imparare. La parte più difficile fu naturalmente la gestione dei processi asincroni sul client, che era una applicazione WinForm scritta su .NET Framework.

Una rapida occhiata al codice di esempio presente nell’articolo di Somasegar è meglio di mille parole. ‘The Old Way’ vs ‘The New Way’ ha un vincitore evidente, ed è la New Way. Mi piace molto il concetto della nuova keyword Await, è una soluzione così elegante! Come sempre in questi casi occorrerà scendere nei dettagli per verificare l’affidabilità di questa nuova soluzione.

La  CTP è già disponibile per il download, attualmente solo per le versioni inglesi di Visual Studio 2010.

Peccato sia disponibile solo in formato PDF, qualcuno dovrebbe approntare una pagina wiki o qualcosa di simile che riproduca questi contenuti.