Developer 2.0 - a software personality

I'm just back from Almens (Swiss) after a day of talking about stuff on several things in mine interests with a good friend Tim Mackinnon. After some talks that gave me a better understanding on how architecture are changing, they're ready to be dumped on a blog entry.
Before start describing the 2.0 I need to go more in depth about the evolution of an Architect form 1.0 to 2.0
In 1.0 he is responsible for:
- the architecture of the system including component reuse (logical and physical reuse),
- finding patterns for problem solution, - driving the philosophy in separating concerns between core component.

Meanwhile, Developer 1.0 requires analysis and designs before writing a line of code, the 2.0 approach is starting from a business feature and instantly writing it. A 2.0 architecture emerges as the code's soul, like when a voice comes from the soul of kid. The soul must be educated, and the role of the architect should be as educator to an architectural approach by iterating over all the development content and all the developers while they're under pressure in releasing line of code. In this way, architects facilitate the emerge of an architecture thought as the Software Personality. With their new approach in linking developer 2.0 contents (code, documentation, feature, etc.) they're are creating those links that enforce the soul of software. Personality increases day by day, line by line, and architecture emerges with it and consolidates with it. Modern architects linking code snippets with tags of a specific context (architecture for example) are implicitly educating code with a personality. Code behavior is the feature implemented, and the old fashioned architecture diagram is an outcome of what is implicitly related inside the code by architects; both the logical and physical statement. The analysis of those links between things produces different graph of related things, and those graphs can be drilled down by following all the tags.

- architecture cloud -

The above diagram can be derived by analyzing tags and relationship between tags: architecture is a derivation by the tag graph inside the system. By having it expressed as a graph from the analysis of the system, it can be thought as an architecture cloud, where the most important component is bigger than the others and when dependencies between component are inherited from tagging. An architect 2.0 is responsible for creating the culture of tagging components to create the 1.0 hidden relationship between logical and physical components. This constitutes the soul of the application that must grow with the system day by day in a pragmatic way by adopting feature to code (as the voice) to the soul. I would like to go more in dept in a future post about the tool. An architect 2.0 should use for maintain upstanding a soul of a system.

Developer 2.0 - Tagging for developers

Developers are building sophisticated tagging system, clouds and drill down mechanism to explore them that project their service in a 2.0 scenario.

Tagging is implemented because it gives lots of benefit in managing and finding contents. Developers should gain this benefits directly from the technology they implement while developing an application.

For example consider if you're writing an application module that consist of:

• a web page
• a javascript file
• a controller object

Tagging them with a tag like module: bookmarklet a developer can consistently declare a unit of development and group logical information together.
Tagging evolves an architect by letting a user to perceive an application in several form. If two files are tagged with an architectural block like the previous block, an extra information can be derived: those two components have a relationship and this relationship should be preserved.

Evolution of a tag cloud

Tag clouds are an impressive way to show which is the major taxonomy on a given content. In my Developer 2.0 idea, tag cloud could be a starting point to get information about how software is implemented and the ranking of each tag is derived, as in the common way, from the tagged contents (sources, documents, etc.).
Filtering tags on a tag cloud gave having a specific namespace, should catch immediately which is the most complex behavior of the system in terms of number of artifacts in it.
In a tag cloud like this, tag names should be arranged by thinking the idea that a content is a neighbor to another content if they share the same tag. All those two content have different tags on and depending on their neighborhood they are showed near by on the tag cloud.

Imagine if you like to browse a tag cloud filtering for namespace: architecture:

Cloud is composed of:

architecture:payment

architecture:messaging

etc.

If a specified payment component notifies troughs the messaging platform a transaction completion, it is tagged by the developer both as "architecture: payment" and "architecture: messaging." Those two tags are now neighbors and in a tag cloud they will be showed, or better linked with their specific size.

This is a new, modern way to have a diagram of how an architecture evolves and the tag cloud can be computed over time and this is a great opportunity a tagging system in the developer 2.0 environment introduces.

I'll continue in the next posts, about how tagging can help me - as a developer - in doing better.

Developer 2.0 - from Code to Content

Nowadays, development and tools are focusing on better IDE that brings best to developers are not giving a new sense of what development could be.
Developing as a business, having an industrial approach, requires to build software considering quality with the best language of the world and documenting all for all the steps requiring while delivering software that satisfies a particular business.

Speaking with modern programmers, I can feel them like to write code in a more expressive and natural language so they don't need to write external documentation and this helps. Other developers to better understand the code while reading it.
Developers don't like writing documentation for two reasons:

1. documentation is hardly maintainable when code evolves and, maybe, there is not time to maintain it;
2. documentation is not a compiled artifact and developers don't see it for production purposes

I see developers that want to discuss about their code on blogs where they show the techniques around their algorithms, or I see developers that are sending code snippets to other developers by email, asking them to refactor that class in that code portion.

Code is the central point in doing development, and for programmers it's a content they continuously produce over time, share and exchange with others.

Nowadays on the web 2.0 era, development is talking about how to address 2.0 issues for some business case and is not addressing development as a community work where code is a content produced by the community.

Thinking about code as a content, developers when producing it should

• publish comments on it;
• blog and reblog it;
• tag it with some more development oriented tags;
• bookmark it.
  

Like every community Developer 2.0 community should have an online space where to live and where to publish its content (code). Code should be edited on line and for each code snippet (method, class, blocks) a developer should add comments (like she does), should blog it, should tag it, or should bookmark it.

Code editing and browsing
Working, sometime as a developer, I usually develop with an open page to a wiki page where I write stuff about architecture, about why I chose to implement those lines of codes in such way etc, and I work with the Text Editor to edit my lines of codes. Every time, I would like to a wiki page to the developed code, I enclose the wiki's code link inside the code for future better understands. When finished I commit on the version control and I move on the next feature.
Thinking about an evolution if the code is recognized as a content, it will be managed like the text I write on the wiki and wiki will be managed as comment in the code. A development platform for 2.0 should let a developer to work on a workspace where code is edited online in a 2.0 fashion: like a blogger does while blogging. Browsing would be the same, you browse the code space and while browsing you can see all is around code.

Code commenting
Traditional code commenting is done using commenting statement offered by languages, and comments are written in a sparse way depending on the purpose. They are written near the code, on wiki pages, on documents (word etc.) and are written in version control commit messages while checking in, tagging and branching.
In a 2.0 fashion commenting is like when a user read a blog and comment it adding a comment to the post. Thinking the code as the content lets developers to add comment to the code. In this way other developers to browse the code content and to read the history comments on it. Comments are now content and follow the same life cycle of the code because they're linked to the code.


Content Tagging
Tagging lets a developer to add some extra information about his code. A tag helps a developer in declaring a purpose of something inside his code. Already, developers use tags in their code development having several purposes:

• to remark to do list
• mark code generation (xdoclet docet)
• to appoint something to remember
• to maintain a group of file of different revision as a version (version control tag)

In the principle of thinking code as content, a developer can tag everything with differently kind of tags.
Thinking about a tag name space, development should implement a thing of tag purposes (architecture: component, assumption: statement, etc.) where tags are "tagged" with a name space and a user or a content aggregator should aggregate for that specific tag. In this way, a user can filter for a specific tag to have a specific context idea of the application. For example, filtering for the "architecture" name space lets to retrieve all the contents about it and have an architectural idea.

Content blogging
Blogging helps developers in sharing ideas that sit around some implemented codes, like a way of explaining the reason of why a portion of code is implemented in such way. Blogs are per user, and are linked to the content that has originated the thoughts.

Bookmarking
When a developer finds something good, he bookmark it on a social bookmarking site like del.icio.us and shares it with others.
On the principle of code as a context, each code snippet can be thought as addressable content and those content should be bookmarked directly on a bookmarking platform.

Endnotes
Code in this era is becoming a content, and everything circle it. Code, comments, tags, bookmarks are exchanged in the developer environment so that other can see what is going on.
The syndication lets users to subscribe to a set of topic and to be notified when something in the development process occurs of the interested topic.
Developers should work in a community as a community where there is friendship between them. Development community should aggregate in a community application all the developers that produce their archetypes there.

I would like to evolve this idea of Developer 2.0 in future topics, where I can go in depth in concept like friendship, blogs and tags or tools around developer 2.0. Stay tuned on this blog to check how these ideas are evolving and how I'll do to make them possible.

Learning on the Wave of what is going on: the Twitter Way

Well socialware is shifting from a buzzword to really good implementation that help in develop and know faster what is going on right now.
I would like to write this post, to show how I'm using twitter and why I think twitter is a good social interaction tool.
Twitter enables users to configure a Gmail account which receive twitter messages from their friendship. This could be considered as another gateway of the flooding information, where people is still a passive victim of what is going on.
The twitter bot can be instructed and if you there are custom messages that instruct the twitter bot:

• with on you are asking of being flooded about messages;
• with off your are asking to shut up.

But, how can I gain benefits from the public twitter time line?

Twitter bot allows to track something on the time line and to grab it in your gmail jabber account. In this way, if you want to start learning what's going on in a specific topic just issue

track specific topic

And the twitter bot is instructed about it and you start receiving a flood of information that contains the specific topic and when a user around the world is citing a specific topic, you will receive notification about it without being friend.
This is a really powerful mechanism I use to learn what is going on, and to have it notified on a client application like iChat or other instant messaging client. I read fast the topic notified, and I chose those topics with goods links.

If you want to learn about fashion, or thinking about a gift just instruct your bot:
track fashion
track gift

And coming back just issue untrack keyword to stop receiving notification from the network.

To configure your bot you need:
- a Google talk account following the Google site
- a twitter account configured to deliver to your Google account in the device section of your account settings

Now you can setup a client and start enjoying what's on your wave!

Developer 2.0 - part 1

Web 2.0 is not only a buzzword that makes people better, it's a movement of things that shift from an era to another. 2.0 is making us passing from a mindset to another. The previous mindset is based on the concept of big corporates, big organizations, big teams, big projects, big strategies; the next mindset will focus more on people, on thinking about organization of people and to trust them.

Software development is playing the game of 2.0, and agile methodologies are only a small anticipations of what is in the next scenario. People, with their human values plus technology knowledge are now becoming the central actor of 2.0 era.
People, in their flavor as friends or colleagues are emphasized from the movement and their network is amplified to get them rid of the hierarchy, the title, or position, and to leverage on values and benefits they give to a social environment.

Developer 2.0 is making upgrading the developer’s concept moving from a developer as a resource in a production chain to a developer as a Person that creates value to the process. This is an opportunity that corporates already know and have implemented in the past through partnership agreement between corporates where the objectives of the partnership were values. Now it is time to make Developers thinking that they can think a development environment as a community of partners where they work for the same objective on the same horizon, and everything is shared. Individual knowledge becomes a group knowledge, and individuality is preserved by the mechanism, as though it was when corporate was partnering in respect to their identities.