Cloud Computing

The ‘Cloud’ is actually a stack of different services commonly referred to as Software as a Service (SaaS), Platform as a Service (PaaS) and Infrastructure as a Service (IaaS) that collectively make up the ‘Cloud’.

Infrastructure as a Service (IaaS)

Infrastructure as a Service (IaaS) is a service model that delivers computer infrastructure on an outsourced basis to support enterprise operations. Typically, IaaS provides hardware, storage, servers and data center space or network components; it may also include software. Infrastructure as a Service (IaaS) is also known as Hardware as a Service (HaaS). 

IaaS providers make a very compelling argument for businesses to stop running their own data centers and simply purchase server capacity on-demand and scale up and down as needed. IaaS is an excellent option for organizations with little capital for hardware, fast growing organizations and for those requiring temporary infrastructure. 

IaaS refers to the delivery of scalable cloud computing infrastructure including servers, storage, network and operating system software as an on-demand service. What users gain with IaaS is infrastructure on top of which they can install any required platforms. They may get an operating system, but they still have to manually configure, manage and update numerous components. 

Some free examples:

HP public cloud

Microsoft's Windows Azure

AWS Free

Note: Usually providers take your credit card details when you sign up and store them, ready to start taking your money. If you don’t want to pay for a cloud service, remember to cancel it!

Platform as a Service (PaaS)

PaaS is known as Platform as a Service and also as Cloud Computing Platform. It refers to infrastructure/services that you can use to deploy your own software/solutions.

PaaS can be thought of as a computing platform that allows the creation of software applications quickly and easily without having to purchase and manage the underlying software and hardware infrastructure. It is a little like middleware, the software layer that developers can tap to handle tasks like transactions, security, and clustering, so they can focus on building their custom applications instead of solving those problems repeatedly. But with middleware, you still have to configure it, deploy it on servers, manage, and monitor it. PaaS pulls together all of these middleware functions and offers them to developers. It provides all of the facilities required to support the complete lifecycle of building and delivering web-based applications.

PaaS is highly scalable.

With PaaS, vendors manage runtime, middleware, O/S, virtualization, servers, storage, and networking, but users manage applications and data.

PaaS is a software development platform on which you can design and develop your SaaS application.

Software as a Service (SaaS)

Software as a Service (SaaS) is a software delivery model. It allows end users to access commercial software that is managed from a central location without having to deal with upgrades and patches. The reduced management effort lowers cost of ownership and allows human capital to be allocated elsewhere. Most SaaS applications can be run directly from a Web browser, without any downloads or installations required. SaaS eliminates the need to install and run applications on individual computers.

SaaS refers to a specific application/solution that any business can use. SaaS apps are normally used directly by the end customer. Usually SaaS is sold to the end consumers.

Example: Google’s services such as GMail, Calendar, Maps and Drive.

Redundant Array of Independent Disks - RAID6 vs. RAID 10 (or 0+1)

One of the most unreliable components of the hardware on which our precious information systems run is the good old hard drive.
RAID is an acronym for Redundant Array of Inexpensive (or Independent) Disks. This is a storage technology that combines multiple disk drive components into a logical unit. RAID is basically a group of disks, usually with one or both characteristics of parity and striping. Parity is redundancy of your blocks of data on the disks; striping allows the individual drive speeds and feeds to add up, giving you more performance than a single disk could provide.
RAID is a form of fault tolerance. A RAID array is a collection of drives which collectively act as a single storage system, which can tolerate the failure of a drive without losing data.
There are five key RAID solutions:

• RAID 0 (striping)
• RAID 1 (mirroring),
• RAID 5 (striping with parity),
• RAID 6 (striping with double parity) and
• RAID 10 (mirroring with striping).

RAID 0 - Striping

RAID 0 is a striped disk array without fault tolerance. RAID Level 0 provides high I/O performance at low inherent cost. Despite the name, RAID 0 is not actually RAID, unless it is combined with other technologies to provide data and functional redundancy, regeneration and rebuilding.

RAID 1 - Mirroring

Each disk in a mirrored array holds an identical image of user data.
Mirroring is extremely stable as the process is so simple, but it requires you to purchase twice as many drives as you would need if you were not using RAID at all, as your second drive is dedicated to redundancy. Write speeds are equivalent to a non-RAID system while read speeds are almost twice as fast in most situations, as during read operations the drives can access in parallel to increase throughput.

RAID 5 - Striping with Single Parity

In this RAID type data is written in a complex stripe across all drives in the array with a distributed parity block that exists across all of the drives. By doing this RAID 5 is able to use an arbitrarily sized array of three or more disks and only loses the storage capacity equivalent to a single disk to parity. A RAID 5 array can survive the loss of any single disk in the array.
RAID 5 is often used because of its cost effectiveness, due to its lack of storage capacity loss in large arrays. Unlike mirroring, striping with parity requires that a calculation be performed for each write stripe across the disks and this creates some overhead. Therefore the throughput is not always an obvious calculation and is dependent heavily upon the computational power of the system doing the parity calculation.
Advantages: Highest Read data transaction rate. Medium Write data transaction rate.
RAID 5 suffers from being able to lose only a single drive.
When capacity is at a premium RAID 5 is a popular choice because it loses the least storage capacity compared to other array types.

RAID 6 - Redundant Striping with Double Parity

RAID 6 is an independent data disks with two independent distributed parity schemes. RAID 6 is practically identical to RAID 5 but uses two parity blocks per stripe rather than one to allow for additional protection against disk failure. If a disk fails, the array is still redundant. Even a second drive can fail and the array will still continue to operate.
RAID 6 is special in that it allows for the failure of any two drives within an array without suffering data loss. To accommodate the additional level of redundancy a RAID 6 array loses the storage capacity of the equivalent to two drives in the array and requires a minimum of four drives.
RAID 6, used in a large array, introduces a very small loss of storage capacity while providing the assurance of being able to lose any two drives. It provides for an extremely high data fault tolerance and can sustain multiple simultaneous drive failures.
RAID 6 has very poor write performance.

RAID 10 - Mirroring plus Striping

Technically RAID 10 is a hybrid RAID type encompassing a set of RAID 1 mirrors existing in a non-parity stripe (RAID 0). RAID 10 is implemented as a striped array whose segments are RAID 1 arrays. With RAID 10, drives must be added in pairs so only an even number of drives can exist in an array.
RAID 10 can survive the loss of up to half of the total set of drives but a maximum loss of one from each pair. RAID 10 does not involve a parity calculation, giving it a performance advantage over RAID 5 or RAID 6 and requiring less computational power to drive the array. RAID 10 delivers the greatest read performance of any common RAID type as all drives in the array can be used simultaneously in read operations. Transactional performance with RAID-10 is good because either disk in the mirror can respond to read requests. No parity information needs to be calculated so disk writes are handled efficiently. Each disk in the mirrored set must perform the same write.

If a disk fails in a RAID-10 array, write performance is not affected because there a member of the mirror can still accept writes. Reads are moderately affected because now only one physical disk can respond to read requests. When the failed disk is replaced, the mirror is again established, and the data must be copied or rebuilt.

RAID 10 can tolerate up to 50% loss of drives if one member of every pair would fail. It provides high reliability combined with high performance.
Disadvantages: Very expensive.

As a conclusion

1. In RAID 10, if you had bad luck and lost 2 drives in one of the mirrors (very likely they would wear out at the same time because they are doing the same workload!), you'd lose your whole array. On the other hand, the rebuild time for RAID-6 is very much longer vs. disk-to-disk clone for RAID-10.
2. In RAID 10 array, disk capacity is cut in half, but it requires less computational power to drive the array (then RAID-6 arrays).
3. RAID 10 provides very high Read/Write performance combined with high reliability.RAID-6 provides very high reliability with high Read performance, but low Write performance.
4. RAID 10 arrays are typically used in environments that require uncompromising availability coupled with exceptionally high throughput for the delivery of data located in secondary storage. RAID-6 arrays are good solution for critical applications.

Approximate Read/Write speed correlation
RAID Level	Read speed
RAID 0 (striping)	Read speed =            1 x ( Write speed )
RAID 1 (mirroring),	Read speed =            2 x ( Write speed )
RAID 5 (striping with parity),	Read speed =   ~       4 x ( Write speed )
RAID 6 (striping with double parity)	Read speed =   ~       6 x ( Write speed )
RAID 10 (mirroring with striping).	Read speed =            2 x ( Write speed )

Mind-Mapping

A mind map is a diagram used to visually outline information.  The modern mind mapping is popularized by Tony Buzan.  Here I made a mind map of chapter 18 of the C# book. I hope you find it useful… 

Mind Map:  Set , Dictionary, Hash Table

C# Задача: Калкулатор с повреден екран

Условието

Най-общо това е задача, в която имаме екран на калкулатор, който може да показва до 18 цифри включително. За визуализирането на всяка цифра се използва 7-сегментен дисплей, но някои от сегментите на дисплеите са изгорели и не светят.

7-сегментен дисплей

 Ако на входа се подаде това, което се вижда на екрана на калкулатора: 
- броя на 7-сегментните дисплей ( т.е. броя на цифрите ) и 
- състоянието на всеки един от сегментите на съответния дисплей (свети =„1“ или  „0“= не свети – независимо от причината изключен или изгорял), 
то задачата е да се определи, кои са възможните числа (поредици от цифри), които калкулаторът би могъл да показва в този момент.

Например, ако е дадено че има само един 7-сегментен дисплей и нито един сегмент от него не свети, то е възможно той да показва всяка една цифра (ако всички сегменти са изгорели – ние просто не я виждаме).

Целта е, като резултат да се изведе броя възможните числа показвани от калкулатора  (при зададеното състояние на сегментите), както и списък от тези числа сортирани в нарастващ ред.

Пълното условие на задачата можете да намерите тук.

Решението

Това е интересна задача, чието решение, поради ограниченията отнасящи се до времето за тестване, системните ресурси и големият брой възможни комбинации, не може да бъде решена с рекурсия, макар това да е първото, което би хрумнало на повечето хора. За да издържи тестовете, обикновено задачата се решава с техники от динамичното оптимиране.

Тук обаче ще си позволя да предложа едно друго (според мен много по-лесно разбираемо) решение, което покрива всички тестове.

Решението можете да намерите тук.

Идеята

За да предположим, коя цифра показва някой от 7-сегментните дисплеи , ние ще проверяваме кой сегмент със сигурност не трябва да свети, за да е възможна визуализацията на дадена цифра.

digits

За тази цел първоначално ще ни трябва да знаем за всяка цифра от 0 до 9,  кои сегменти не трябва да работят, за да може тя да се визуализира. Например за да се визуализира „0“ със сигурност сегмент „G“ от картинката не трябва да работи ( и дали другите сегменти от дисплея работят или не няма никакво значение).

Коментари по решението

За да си запишем входа ще използваме двумерен масив (от байтове) digits , който ще съдържа нули или единици в зависимост от това дали даден сегмент свети или не.

Ние последователно ще поставяме всички възможни цифри на съответната позиция до момента в който приключим и със всички дисплеи,  като започнем от последния дисплей (т.е. от този показващ единиците).  

Нека да сме определили, че за дисплея показващ единиците възможните цифри са

 „0“ и „8“.

Ако дисплеят е само един това ще са и нашите решения.

Ако обаче имаме още дисплей (за десетиците, за стотиците и т.н.) трябва да продължим. Следва да проверим, кои цифри могат да стоят на позицията на десетиците (предходния дисплей) – нека те да са „1“ и „2“. Тогава, за да получим решението ще трябва последователно да ги поставим  на мястото на десетиците ( пред вече получения резултат за единиците). Така за примерните цифри ще получим следните възможни решения:

1 0 ; 1 8 ;

2 0 ; 2 8 ;

Ако имаме още един дисплей (за стотиците), и за него сме получили, че е възможно той да показва „0“ и „8“ , то възможните показвани числа от калкулатора биха били :

0 1 0 ;  0 1 8  ;  0 2 0 ; 0 2 8 ;  (получени от вмъкването на „0“ преди предходния резултат)

8 1 0 ;  8 1 8  ;  8 2 0 ; 8 2 8 ; (получени от вмъкването на „8“ преди предходния резултат)

Както забелязвате, всеки път броя на възможните за показване числа се увеличава толкова пъти, колкото е броя на възможните за показване цифри от текущия дисплей.

Получените комбинации ще пазим в един List <string> result.  В този пример в началото той ще има два елемента:

result[0] = „0“ и

result[1] = „8“

Когато добавим и втория дисплей, елементите на List <string> result ще са:

result[0] = „0“;  

result[1] = „8“;  

-----------------------------

result[2] = „10“ ;        ( „1“+ result[0] )

result[3] = „18“ ;        ( „1“+ result[1] )

result[4] = „20“  ;       ( „2“+ result[0] )

result[5] = „28“ ;        ( „2“+ result[1] )

В моето решение е работено със стрингове и за получаване на новите елементи е използван StringBuilder, но ако предпочитате да работите с числа то текущата цифра трябва да се умножи по 1, 10, 100 и т.н. в зависимост от това дали е на позиция на единиците, десетиците, стотиците … и последователно да се събере с предходните резултати.

Вижда се, че това което ни трябва са само елементи от result[2]  до result[5] вкл. , така че или трябва да изтрием предходните или да използваме допълнителна  променлива (startIndex), която пази индекса, от който започва нашето решение.

В решението, което предлагам излишните елементи не се премахват, с цел да се спести процесорно време (което е най-оскъдния ресурс според условието на тази задача), за сметка на използване на малко повече памет.

Остана само да отпечатаме получения резултат, като незабравяме да започнем от индекса пазен в нарочната променлива, а броя комбинации ще бъде броя на елементите в списъка, които са решение на нашата задача, т. е. броя елементи от стартовия индекс до последния елемент вкл.

Готово. J

Какво всъщност направихме и защо успяхме да минимизираме времето за изпълнение на програмата:

• Правихме предположения за цифрите на база на неработещите сегменти на всеки дисплей - това са само девет проверки за всеки дисплей ( 8 винаги е възможна цифра); 
• Записвахме полученото в List <string> result , без да премахваме ненужните елементи от него – за да не губим време за пренареждане на списъка;
• 3апочнахме да четем числата отзад напред, за да не губим процесорно време и ресурси за сортирането им.
• Лесно определихме броя на комбинациите – като разлика от дължината на списъка и индекса на първия елемент от него, който е решение на задачата.

Приключи първата сесия на обучаващите се за софтуерни инженери в Телерик

С края на 2012 година, дойде и краят на първата сесия в Софтуерна Академия Телерик. Две бяха дисциплините, в които обучаващите се трябваше да покажат знания и да премерят сили.
Пръвият изпит бе по "HTML  и уеб технологии", където от явилите се 1449 души, 1337 го издържаха успешно. Особено приятно впечатление прави факта, че над половината от тях - 778 души имат отлични резултати.
Изпитът по втората дисциплина "Основи на програмирането и C#" се състоя от две частти - тест и практическа част (решаване на задачи). Най-добре представилите се на теста ( 508 човека) получиха правото да се явят на практически изпит. В крайна сметка, от явилите се 1119 души, 925 го издържаха успешно, 360 от които с отлична оценка.
Следващата сесия ще бъде в края на февруари 2013 година, където обучаващите се ще мерят сили в дисциплините "C# програмиране - част II" и "CSS Стилизиране" .