cloudStorageAccount = CloudStorageAccount
  .Parse("UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://ipv4.fiddler");

Note, that Fiddler instance should be running in order for the name to resolve

practically, even in the abstract world, we are talking about the almost-infinite scalability of N Log N costs,where log is based on some pretty large number.

Such architecture fits the concepts of cloud computing really well and is based on a few important assumptions:

System manages entities (aggregate roots in DDD concept) that are identified by some globally unique id and always fit to a single machine or a small cluster. Examples of entities are: customer, patient, project etc. We can always ensure transactional consistency within a single entity.

As system grows, these entities will be redistributed between various machines in order to accommodate the load. We can never know for sure if certain entities are on the same machine or not. Hence, it is impossible to update two logically referenced entities in a single transaction.

Architecture should consider and build upon these limitations from the start, using messaging to provide communication between the different entities.

Infrastructure can usually guarantee, that messages will be delivered at least once. Due to infrastructure limitations and costs, order and single delivery are not always guaranteed. Activities (sagas), that represent partnership of the entity with some specific sender,are responsible for handling such interactions, implementing ordering and reduplication as needed. Idempotent operations generally do not need this.

Real-world businesses and operations have been established in the world of slow and unreliable communications (snail mail, telegrams, phones etc.). They already accommodate logic of activities, uncertainty, assumptions and eventually consistent systems in order to stay successful and profitable.

In more detail these assumptions are discussed in article on: Space Travel and Infinitely Scalable Solutions.

In order to model and implement such entities, one could use domain-driven design. Architecture implementations of the overall scalable system are recommended to follow CQRS principles.

He recently has worked on the projects like:

• Bing Infrastructure.
• Cosmos - a petabyte store (working towards being an exabyte store) which runs over tens of thousands of inexpensive computers.
• Autopilot.

There is a blog

Pat has authored a set of extremely interesting and thoughtful papers:

• Life Beyond Distributed Transactions: An Apostate's Opinion

This is 10 page PDF on scalability in really large applications. Ideas from this article are explored further in Space Travel and Infinitely Scalable Solutions.

• Memories, Guesses, and Apologies

"Business realities force apologies. To cope with these difficult realities, we need code and, frequently, we need human beings to apologize. It is essential that businesses have both code and people to manage these apologies."

• Building on Quicksand

These papers help to shape understanding and body of knowledge in building massively scalable systems. It's strong recommendation to read these if you are studying CQRS and xLim or simply building solution for the cloud computing environment.

SELECT Name from sysobjects where xtype = 'u'

List MS SQL tables with row counts:

SELECT object_name (i.id) TableName, rows as Row_Count
FROM sysindexes i INNER JOIN sysObjects o ON 
  (o.id = i.id AND o.xType = 'U')
WHERE indid < 2
ORDER BY TableName

Explore table columns:

SELECT 
  TABLE_NAME as 'Table', 
  COLUMN_NAME as 'Column', 
  COLUMN_DEFAULT as 'Default',
  IS_NULLABLE as 'NULL',
  DATA_TYPE as 'Data', 
  CHARACTER_MAXIMUM_LENGTH as 'LEN',    
  NUMERIC_PRECISION as 'Prec',
  NUMERIC_PRECISION_RADIX as 'Radix',
  NUMERIC_SCALE as 'Scale'

 FROM INFORMATION_SCHEMA.Columns

Check indexes from table:

EXEC sp_helpindex 'table_name'

Extensible Messaging and Presence Protocol (XMPP) (formerly named Jabber) is an open, XML-based protocol originally aimed at near-real-time, extensible instant messaging (IM) and presence information (e.g., buddy lists), but now expanded into the broader realm of message-oriented middleware.[2] It was developed by the Jabber open-source community in 1999. Built to be extensible, the protocol has been extended with features such as Voice over Internet Protocol and file transfer signaling.

XMPP PROs

• Decentralization - like in email; anyone can run their own XMPP server and there is no central master server.
• Open standards - the Internet Engineering Task Force has formalized XMPP as an approved instant messaging and presence technology under the name of XMPP, and the XMPP specifications have been published as RFC 3920 and RFC 3921.
• Long History - XMPP technologies are used since 1998. Multiple implementations exist and are supported by companies like Sun Microsystems and Google.
• Security - XMPP servers may be isolated from the public XMPP network (e.g., on a company intranet), and robust security (via SASL and TLS) has been built into the core XMPP specifications.
• Flexibility - Custom functionality can be built on top of XMPP.

XMPP CONs

• Presence data overhead - XMPP currently has a large overhead in delivering presence data to multiple recipients.

• In-band binary data transfer is inefficient - Because XMPP is encoded as a single long XML document, binary data must be first base64 encoded before it can be transmitted in-band. Therefore any significant amount of binary data (e.g., file transfers) is best transmitted out-of-band, using in-band messages to coordinate.

How to Query XMPP Server

cmd>nslookup
Default Server:  XXX
Address:  8.8.8.8

> set q=SRV
> set noverbose
> _xmpp-client._tcp.gmail.com.

References

• XMPP wiki page (this article contains excerpts from it)
• XMPP Standards Foundation
  • Clients
  • Servers
  • Libraries

show tables;

Other show statements

Table creation script:

show create table %tablename%;

In an oversimplified manner, CQRS separates commands (that change the data) from the queries (that read the data). This simple decision brings along a few changes to the classical architecture with service layers along with some positive side effects and opportunities. Instead of the RPC and Request-Reply communications, messaging and Publish-Subscribe are used.

BTW, check out Getting Started with CQRS! You'll find links to best articles, videos and samples on Command-Query Responsibility Segregation (with a dash of Cloud Computing).

If we go deeper, Command-query Responsibility Separation is about development principles, patterns and the guidance to build enterprise solution architecture on top of them.

Such enterprise solutions aim to be:

• Scalable
• Focused on the business rather than the technology
• Can grow to handle complex problems without growing development costs
• Adapt to changing business requirements
• Efficiently integrate with other software and systems
• Benefit from the cloud computing
• Inherently handle multiple users

While going for these goals, CQRS attempts to solve problems of:

• Performance bottlenecks and scalability
• Concurrency conflicts, their resolution and prevention
• Data staleness
• Complexity of the design, development and maintenance

Related links:

• Getting started with CQRS.
• Top 10 benefits of CQRS (in a nice downloadable PDF).
• CQRS introductory video.
• Clarified CQRS paper by Udi Dahan.
• DevTeach Video
• DDDD, CQRS and Other Enterprise Development Buzz-words

This article is a part of Software Development Body of Knowledge ABC series. You can subscribe to RSS feed to stay updated.

Related Links:

• defined parameters and return arguments;
• calling conventions;
• usage limitations.

For example, here's how a piece of Twitter REST API looks like:

• Twitter REST API Method: statuses update
• URL: http://twitter.com/statuses/update.format
• Formats: xml, json, rss, atom
• HTTP Method(s): POST
• Requires Authentication: true
• API rate limited: false
• Parameters: ...
• Response: ...

There are a few categorizations of APIs in the software development world.

Web APIs define interfaces for interacting with various web sites and services in the Internet. These APIs usually use Hypertext Transfer Protocol (HTTP) requests for passing around data represented in JavaScript Object Notation (JSON) or Extensible Markup Language (XML) formats.

Twitter REST API, mentioned above, is an example of such Web API.

Operating System APIs represent low-level methods exposed by the operating system (OS) that could be used by software applications to integrate with it. Windows API (or Win32) and POSIX definitions are among the most known examples.

Software APIs are usually exposed by software vendors willing to provide integration capabilities for their products.

Here's the simplest example of Virtual Machine - Windows 7 running Windows XP in a VM to provide backwards compatibility for the older applications:

Here's another example - Sun VirtualBox running Ubuntu x64 server within Windows 7:

These were the examples of Operating System Virtual Machines. Another type of VM is Application Virtual Machine, that runs applications and scripts in an isolated virtual environment. Examples of that would be Java VM or .NET Framework VM.

VMs and Software Development

Virtual Machines are getting very important and widely used these days. This happens due to the improvements in hardware and virtualization capabilities along with the numerous benefits offered by the technology.

Some of usage scenarios include:

• Quality Assurance teams get the ability to test applications, their deployments and upgrades more efficiently. Testers don't need to have multiple OS and installation configurations available any more. A set of VM files (that are easy to share) is a replacement for that.

  Additionally, it is quite easy to configure continuous integration to run actual integration tests within differet virtual machines (emulating various OS and setup configurations), thus providing a better code coverage and issue detection.

• Software Developers could try out latest changes and various multi-server deployment configurations within virtual development environments.

• Cloud service providers could sell finely-grained computing capacities to customers in form of the VM slices. Customer is able to configure his Virtual Machine any way he wants.

  Should they want to change hosting provider, they just need to move a single VM from one environment to another.

• For complex enterprise applications (spawning multiple machines and server roles) virtual machines provide high-level separation of concerns, simplifying software evolution and maintenance.

• It is really easy to launch multiple virtual machine clones from one VM file. This simplifies scaling and cloud bursting scenarios for organizations.

Related links:

• Virtual Machine on Wikipedia
• Development server meets virtualization
• Configuring Virtual Development Environment

Simply put, Agile Software Development is a group of software development methodologies that work quite well when:

• projects are not mission-critical;
• business requirements change extremely fast;
• there are great developers available;
• development teams are small;
• development culture and mentality favors self-organization and self-learning.

In other words, Agile works quite well in situations when some unique software project has to be delivered really fast in order to seize the market opportunity. This works because Agile software methodologies allow development teams to adapt quickly to the rapidly changing business requirements. This happens because of:

• short development iterations allowing to start getting feedback early in the project's life-cycle and incorporate it into the product fast by delivering working software repeatedly and in a timely manner;
• continuous integration helping to reduce development friction and improve quality of a rapidly developing project in self-organizing environment;
• feature-driven development focusing development on delivering features (functionality) bringing real business value to the client (and the project);
• lean software development laying out common principles for efficient software development process;
• eXtreme Programming pushing lightweight software development methodologies to the extreme.

Long-term planning (along with some other formalities of a totally controlled project management process) is mostly sacrificed in favor of the flexibility, fast delivery and self-organization. In such a situation we still have to maintain high quality of the project deliverables (while reducing the resource consumption). This is achieved with the help from:

• test-driven development - provides foundation for the Continuous Integration and facilitates change while maintaining stability of the software project;
• pair programming - improves code quality and allows to have more efficient knowledge sharing.

Related Links:

• Agile Software Development on Wikipedia
• Lean Software Development on Wikipedia
• Scrum on Wikipedia
• Planning poker on Wikipedia
• eXtreme Programming on ExtremeProgramming.com

This article is a part of Software Development Body of Knowledge ABC series. You can subscribe to RSS feed to stay updated.