Fiz um trabalho de Sistemas Operacionais onde o enunciado é:
Desenvolver um simulador para o escalonamento de braço de disco. Os algoritmos de escalonamento de braço de disco são: ‘FIRST-COME, FIRST-SERVERD’, SCAN, C-SCAN (Circular Scan), CLOOK e SSTF (Shortet Seek Time First).

Fiz em java e não está completo. Alguns tratamentos de erros foram feitos não deixando o usuário cadastrar certos dados.

A primeira parte do programinha é uma firula que através dos dados inseridos, retorna o tamanho do hard disk em GB.

Em seguida vem as requisições dos setores até que se digite um número negativo. É exibido então o deslocamento entre os setores e a média de seek.

Lembrando que é tudo uma simulação que visa a realidade apenas nos dados retornados e não em como é feito. Explorar o código é a melhor forma de saber exatamente o funcionamento.

Quem quiser colaborar, fique à vontade, o código está no github.

https://github.com/MarceloCajueiro/Disk-Arm-Scheduling

Segue a pequena referência escrita que serão entregues aos colegas.

O que é?

TDD é uma técnica de desenvolvimento de software onde antes de começar o desenvolvimento é escrito pequenos testes de frações de uma funcionalidade, que serão os roteiros a seguir na sua criação.

O TDD segue um ciclo passos básicos:

1. Escrever testes – o desenvolvedor escreve primeiro o teste, visando uma nova funcionalidade. Para tal, ele deve entender as especificações e requisitos. O foco acaba sendo as coisas mais importantes do projeto, o que num desenvolvimento sem metodologia, acaba sendo desvirtuado;
2. Executar todos os testes – deve-se checar os erros, para resolvê-los. O desenvolvimento ocorre sobre as falhas;
3. Escrever código – numa nova funcionalidade, obviamente os testes irão dar erros por não ter nada escrito ainda. É a partir daí que começa o desenvolvimento de código, onde o objetivo consertar, mesmo que não seja de uma forma elegante. Nesse passo a qualidade do código não é levada em conta, o importante é funcionar;
4. Reexecutar os testes – fazer uma nova execução dos testes para checar se os requisitos e especificações foram alcançados;
5. Refatoração - código é analisado e reescrito para uma melhor performance e organização, evitando redundâncias com DRY (Don’t Repeat Yourself, Não se repita).

O ciclo recomeça a cada nova funcionalidade e alteração.

Benefícios:

• Maior entendimento das regras de negócio. Para escrever os testes, tem de saber como tudo irá realmente funcionar;
• Com testes unitários escritos depois do software pronto, ele acaba sendo feito para passar. Ao fazê-lo primeiro, o teste é menos “suspeito”;
• Menor quantidade de manutenção após ser colocado em produção;
• Se comparado ao tempo perdido em manutenção e correção de bugs, torna o desenvolvimento, como um todo, mais rápido;
• Maior facilidade para ser feito documentação;
• Segurança ao fazer modificações;
• Maior valor agregado ao produto.

Geralmente para gerar os teste, são usados bibliotecas específicas de cada linguagem.

Exemplo usando TDD no java com o junit, framework de teste:

// TesteMatematico.java
import junit.framework.*;

public class TesteMatematico extends TestCase {

	public void testaSoma() {
		int numero1 = 3;
		int numero2 = 2;
		int resultado_certo = 5;
		int resultado_testado = 0;
		resultado_testado = Matematica.soma(numero1, numero2);
		assertEquals(resultado_testado, resultado_certo);
	}
}

// Matematica.java
public class Matematica {
	static public int soma(int a, int b) {
		return a + b;
    }
}

Há ainda uma “variação” do TDD, chamado BDD (Behavior Driven Development ou Desenvolvimento Guiado por Comportamento). Segue a mesma linha do TDD, porém, são usados histórias em linguagem humana para gerar os testes, que podem se tornar documentação para o software. O foco são as regras de negócios bem especificadas.

Exemplos de histórias (BDD) usando Cucumber para a linguagem Ruby:

Em inglês:

        Feature: Simple math
                In order to avoid silly mistakes
                As a math idiot
                I want to be told the result of simple math operations

                Scenario: adition
                        Given I have entered 50 into the calculator
                        And I have entered 70 into the calculator
                        When I press add
                        Then I should see 120 on the screen

                Scenario: subtraction
                        Given I have entered 60 into the calculator
                        And I have entered 30 into the calculator
                        When I press sub
                        Then I should see 30 on the screen

Português:

        Funcionalidade: Matemática Simples
                Para evitar erros idiotas
                Como um completo ignorante em matemática
                Eu quero que operações simples de matemática sejam resolvidas para mim

                Cenário: adição
                        Dado que eu digite 50 na calculadora
                        E que eu digite 70 na calculadora
                        Quando eu pressionar "Adicione"
                        Então eu devo ver 120 na tela

                Cenário: subtração
                        Dado que eu digite 60 na calculadora
                        E que eu digite 30 na calculadora
                        Quando eu pressionar "Subtraia"
                        Então eu devo ver 30 na tela

Após escrever as histórias, será usado um arquivo de “configuração” onde as expressões principais são “traduzidas” para linguagem de programação, e assim, testar a implementação.

REFERÊNCIAS

BDD. Wikipedia. Disponível em:. <http://pt.wikipedia.org/wiki/Behavior_Driven_Development>. Acesso em: 12 de outubro de 2010.

TDD. Wikipedia. Disponível em:. <http://pt.wikipedia.org/wiki/Test_Driven_Development>. Acesso em: 12 de outubro de 2010.

TEST-DRIVE DEVELOPMENT (TDD). Alencar, Roberto. Disponível em:.< http://www.devmedia.com.br/articles/post-10025-Test-Driven-Development–TDD.html>. Acesso em: 12 de outubro de 2010.

TUDO SOBRE TDD. Dojo Floripa. Disponível em:. <http://dojofloripa.wordpress.com/2007/09/10/tudo-sobre-tdd/>. Acesso em: 12 de outubro de 2010.

LINKS ADICIONAIS

Algumas considerações sobre TDD e BDD: http://logbr.reflectivesurface.com/2008/10/27/algumas-consideracoes-sobre-tdd-e-bdd/

Desenvolvimento Orientado a Testes: http://improveit.com.br/xp/praticas/tdd

TDD para iniciantes – Para quem quer começar e não sabe como (vídeo): http://www.heroisdati.com/tdd-para-iniciantes-para-quem-quer-comecar-e-nao-sabe-como/

Tudo sobre TDD: http://dojofloripa.wordpress.com/2007/09/10/tudo-sobre-tdd/

Enrolei por estes anos até decidir finalmente focar meus estudos. Me inscrevi no curso de Rails 3 da Egenial e me apaixonei ainda mais pela área de desenvolvimento web, com Rails.

Apesar de iniciante, estou estudando muito para me inserir no mercado o mais rápido possível. Na busca de um networking estadual, percebi que aqui em Santa Catarina a comunidade andava muito parada, mas na verdade faltava apenas um empurrão, alguém para fazer a frente.

Entrei no grupo Rails-SC e provoquei o pessoal. Ele estava fraco precisando de mais pessoas ativas. Resolvi então seguir a linha dos Grupos de Usuários Ruby e criar o de SC.

O primeiro passo foi entrar em contato com grandes nomes de Ruby/Rais do Brasil para pedir o apoio que seria necessário para disseminar a notícia. Vi nessas pessoas uma abertura muito boa, a maioria além de fazer o que eu pedi, anunciar no twitter, respondeu o e-mail dando apoio.

Hoje, meio mês depois, a comunidade já conta com 50 membros e o desenvolvimento do site está rumo a conclusão nas próximas semanas.

Graças ao grupo, alguns membros irão juntos ao RS on Rails e lá nos encontraremos a outros para oficializar o primeiro mini encontro GURU-SC.

PS¹.: Repositório do site GURU-SC;

PS².: agradecimentos especiais aos que deram RT no @Gurusc: @AkitaOnRails, @Urubatan, @ViniciusTeles, @Tapajos, @JoseValim, @DanielvLopes, @CarlosBrando, @FabioKung, @Taq, @Alegomes.

De uns dias para cá ele estava muito lento devido ao pouco espaço que havia reservado no HD, não encontrando uma solução viável para aumentar o tamanho de forma efetiva sem chances de erro, formatei a máquina.

Após isto o windows parou de entrar, tentei de tudo para o GRUB voltar a identificá-lo, mas não teve jeito.

Ao reinstalar o Windows 7 o problema contrário aconteceu. A distro deixou de ser legível. Mexendo no lixo do Google encontrei uma solução simples para download no baixaki: “Super Grub Disk“.

É um .iso bootável para poder entrar no linux outra vez e posteriormente reativer o GRUB.

Como odeio ficar muito tempo procurando algo e não achar a solução eficaz, fica a dica para quem tiver o mesmo problema.

Sem desvios? #fail

Por volta de novembro de 2008 meu ex-colega me falou sobre Ruby on Rails, um ótimo framework web numa linguagem muito interessante. Em seguida estudei e rolou a famosa química citada no “Why’s (poignant) Guide to Ruby“. Conheci grandes nomes como o Akita, o Carlos Brando, Urubatan, DHH, Matz, Tapajos, Teles entre vários outros. Como não era a tecnologia que eu precisava para crescer na empresa, fui deixando para depois o aprendizado. Se arrependimento matasse.

Em julho de 2009, percebendo que não teria futuro naquela organização, pedi para sair com o objetivo de fazer freelance de sites e garantir o meu dinheiro. A tecnologia que “meu coração” pedia era Rails, porém, mais uma vez foi adiado o momento quando um amigo me apresentou o Joomla! para desenvolver rapidamente projetos. Essa parte da minha vida durou pouco porque em seguida fui chamado para cargo de Agente de Correios (concurso da ECT) o qual exerço até hoje.

Neste mesmo período fui aprovado no vestibular da UFSC, campi de Araranguá, para o curso de Tecnologias da Informação e Comunicação.

De uns meses para cá voltei a ficar atento as novidades da comunidade Ruby, logo, me bateu aquela vontade de aprender de vez essa tecnologia que tanto me fascina e que almejo trabalhar.

Quando fui arrebatado por este desejo lembrei de cara da Egenial, empresa de treinamentos que desde o meu primeiro contato com a linguagem já me chamava atenção pelos seus cursos.

E, finalmente, hoje estou em pleno curso de Ruby on Rails 3 ministrado pelo Daniel Lopes.

O meu trajeto com Ruby/Rails foi algo peculiar por se dividir em etapas de querer e não poder, ou querer, poder, mas mesmo assim não arriscar. Hoje, sem trabalhar na área de TI, mas muito motivado a me engajar no setor, tenho a liberdade de investir nesse conhecimento que me levará próxima parada (sem desvios desta vez).

Alocação sequencial -  Array

• Consiste em colocar os  seus elementos em células de memória  consecutivas, um após o outro.
• Vantagens: pode-se acessar qualquer parte apenas passando o índice e o endereço de alocação da memória;
• Desvantagens: para inserir algum dado no meio da lista é necessário mover os elementos para abrir espaço.

Lista encadeada

• Ao invés dos elementos ocuparem células consecutivas da memória, esta ocupa aleatoriamente;
• Os elementos são armazenados em blocos, chamados nodos, que contém o dado e o endereço do próximo, que será usado para fazer a ligação entre ele com o uso de ponteiros;
• Para acessar a lista, deve-se ter uma variável apontando para o primeiro nó.

Program lista_encadeada;

type
	tDado = integer; {tipo do dado a ser inserido}
	tPtNo = ^tNo; {criando um tipo ponteiro}
	tNo = record {criando o bloco que terá:}
			Dado: tDado; {dado}
			Prox: tPtNo; {ponteiro para o próximo da lista}
		end;

var
	p,q: tPtNo; {variáveis usadas}
Begin
	new(p); {alocação para p}
	p^.Dado := 2010; {o dado do bloco p aponta para o inteiro 2010}
	new(q); {alocação para q}
	q^.Dado := 2012; {o dado do bloco q aponta para o inteiro 2012}
	p^.Prox := q; {indico que o próximo da lista após P é o Q}
	q^.Prox := nil; {indico que o próximo da lista após Q é nil(nulo)}
End.

Neste link há um código (cadastro de nome e sobrenome) com as funções básicas de uma lista:

• Iniciação;
• Inserção;
• Remoção;
• Busca;
• Término.

Ponteiros

Alocação de memória

Estática: o programador faz a declaração das variáveis, ou seja, relaciona previamente as que irá usar ao longo do programa. Ex.: Array.

Dinâmica: o programador usa comandos que permitem (por meios de ponteiros) alocar e desalocar espaços de memória durante a execução do programa. Ex.: Listas encadeadas.

• Definição de ponteiros: variáveis que armazenam posições de memória;
• Guarda um dado ao apontá-lo ou apontando para uma variável que o contém;

// Ex.:
x^ := 123,34; // aponta para o valor
y := "Pascal"; x^ = y // aponta para uma variável que contém o dado

• Execução de um programa bem feito com ponteiros é mais rápida e evita desperdício  de memória;
• Variável int pode iniciar com zero, com ponteiros é nil (nulo);
• Usa a função new para alocar memória e dispose para desalocar.

// Ex.:
New(x); //Aloca a memória para x;
x^:= 12,13; //Aponta o valor;
Dispose(x); // Desaloca a memória;

Ps.: prática de uso de ponteiros há no resumo de Listas.

Alguma estrutura são “difíceis” de gravar sem usávas constantemente, logo, ter um lugar para ver como funciona a sintaxe é primordial.

Há uma interessante lista no site do Python Brasil.

Fiz o ultimo exercício da parte de estrutura sequencial, não fiz os anteriores por achar primário (comparado ao meu nível) e o último engloba bastante aprendizado novo para mim.

Aviso desde já que o interessado sou eu, não espere alguém que escreva o que quer ser lido.



Faça um Programa para uma loja de tintas. O programa deverá pedir o tamanho em metros quadrados da área a ser pintada. Considere que a cobertura da tinta é de 1 litro para cada 6 metros quadrados e que a tinta é vendida em latas de 18 litros, que custam R$ 80,00 ou em galões de 3,6 litros, que custam R$ 25,00.

* Informe ao usuário as quantidades de tinta a serem compradas e os respectivos preços em 3 situações:
* comprar apenas latas de 18 litros;
* comprar apenas galões de 3,6 litros;
* misturar latas e galões, de forma que o preço seja o menor. Acrescente 10% de folga e sempre arredonde os valores para cima, isto é, considere latas cheias.

def tintas ()

	nLatas18 = 0
	nLatas36 = 0
	gasto = 0

	puts "Qual o tamanho da área quadrada a ser pintada?"
# variável recebe valor digitado no teclado, o to_f diz que deve ser float
	area = gets.to_f 

	qtdUsada = (area.to_f / 6)
#{qtdUsada} é usada para exibir variável no meio de uma string
	print "#{qtdUsada}l necessários" 
	puts

	puts "1 - latas de 18l que custam R$80,00"
	puts "2 - galão de 3,6l que custa R$25,00"
	puts "3 - misturar usando a forma mais barata"
	uso = gets.to_i
	# case é auto-explicativo
	case uso
		when 1
			nLatas18 = (qtdUsada / 18).round
			gasto = nLatas18 * 80
		when 2
			nLatas36 = (qtdUsada / 3.6).round
			gasto = nLatas36 * 25
		when 3
			qtdUsada = qtdUsada * 1.10
			if qtdUsada > 18
				x = qtdUsada - (((qtdUsada/18).to_i)*18)
				nLatas18 = ((qtdUsada/18).to_i)
				gasto = nLatas18 * 80
				if x <= 3.6
					nLatas36 = 1
					gasto += 25
				elsif x <= 7.2
					nLatas36 = 2
					gasto += 50
				elsif x <= 10.8
					nLatas36 = 3
					gasto += 75
				else
					nLatas18 += 1
					gasto += 80
				end
			else
				nLatas36 = ((qtdUsada/3.6).to_i)
				x = qtdUsada - (nLatas36*3.6)
				gasto = nLatas36 * 25
				if x > 1
					nLatas36 += 1
					gasto = gasto + 25
				else
					nLatas36 = 1
					gasto = 25
				end
			end
		else
			puts "comando inválido"
	end
	puts
	puts "Total R$#{gasto}"
	puts
	# a estrutura abaixo é muito interessante
	# imprime a string se nLatas18 > 0
	# sempre fui acostumado a ver a condição antes, estranhei e gostei
	puts "Latas de 18 litros: #{nLatas18}" if nLatas18 > 0
	puts "Latas de 3,6 litros: #{nLatas36}" if nLatas36 > 0

end

tintas # chama a função

É bom fazer exercícios, cada um aprendo algo diferente.