Por que engordamos? II

Não engordamos porque comemos demais; comemos demais porque engordamos.

Taubes

Na minha releitura da versão em papel e em português do livro do Taubes me senti motivado a fazer alguns comentários sobre algumas partes que me chamaram a atenção como altamente desmitificadoras em relação às teorias correntes sobre as causas da obesidade. Leia abaixo:

Insulina: o hormônio do crescimento para os lados

Os hormônios são os regentes de todo o metabolismo. A maioria das regulações dependem do balé dos hormônios e do estímulo de retroalimentação sobre nossas glândulas causado pelo desequilíbrio momentâneo das substâncias variadas que circulam pelo nosso organismo. A insulina, que aumenta quando o açúcar no sangue sobe, promove a retirada do mesmo do sangue e armazenamento como gordura nas células adiposas. Isto para retirar o excesso de açúcar no sangue já que lá o mesmo é tóxico. O açúcar no sangue sobre mais rápido por conta dos carboidratos.

Assim como o hormônio do crescimento é o que causa o crescimento do corpo, principalmente para cima. A insulina o faz para os lados, principalmente. Quando a criança ou adolescente come muito sabemos que é porque está crescendo. Podemos dizer que ele não cresce porque está comendo mas come porque está crescendo. Em relação ao “crescimento para os lados”  podemos, de forma similar, dizer que não engordamos porque estamos comendo mas comemos porque estamos engordando. Na direção inversa também podemos dizer que não estamos emagrecendo porque estamos comendo menos mas comemos menos porque estamos emagrecendo. Logo na raiz de uma intervenção para corrigir o peso excessivo está o controle da insulina. Como a insulina responde principalmente à ingestão de carboidratos basta reduzir a sua ingestão.

O Dr. Souto nos seu post A CHAVE de tudo – INSULINA resume bem a questão (com base no Taubes, provavelmente).

Ratos de Zucker

Os ratos de Zucker já foram citados no post Qualquer coisa que aumente nosso tamanho nos fará comer em excesso – mais modelos animais no blog do Dr. Souto, que recebeu muita influência do livro anterior do Taubes (Good Calories, Bad Calories). São ratos com predisposição para engordar.

Taubes relata que experimentos com tais ratos que os colocam em dieta podem esclarecer os mecanismos envolvendo nossa massa adiposa. Quando colocados em dieta calórica restritiva não emagrecem. Continuam com uma proporção bem maior de massa gorda em relação à massa magra (músculos e tecidos de órgãos). No experimento de restrição calórica os ratos não tem como comer mais do que os pesquisadores tenham estabelecido. Mesmo assim engordam. Os seus órgãos internos e músculos são menores e parecem ser sacrificados em favor de seu tecido adiposo. Se no limite forem mantidos com fome o seu tecido adiposo, tal como um câncer que drena os recursos vitais, sequestrará o que “precisa” dos órgãos internos e músculos levando à falência progressiva do animal.

Fazendo uma analogia, uma pessoa que faça uma dieta restritiva e que já se encontre em uma espécie de desequilíbrio, embora não genético como no caso dos ratos Zucker, estaria sacrificando a saúde dos seus órgão internos e músculos em favor da sua gordura. Por mais que coma pouco este pouco irá mais aumentar a sua gordura sobrando menos para o resto. Com fome os ratos Zucker morrem gordos. Seu organismo anômalo prefere comprometer a funcionalidade dos órgãos internos e músculos a usar a gordura já acumulada como suprimento. Isto devia servir de alerta para quem quer emagrecer embarcando na tese errônea da restrição calórica.

Nossa massa adiposa é altamente ativa contra a hipótese corrente de ser um repositório passivo do que sobra do balanço energético. No caso dos ratos Zucker o defeito genético causa o desequilíbrio. Naqueles atingidos pela obesidade algum desquilíbrio similar, com causas genéticas ou não, levam a um resultado semelhante.

Lipofilia

idéia da lipofilia é de 1920, segundo citado por Taubes. A hipótese é do pesquisador Von Bergmann. Julius Bauer, da Universidade de Viena,  compara o tecido adiposo dos obesos com um tumor malígno. Asim como o tumor faz o tecido adiposo tem objetivos próprios não se importando com o resto do corpo. É como se saltassem fora do mecanismo da homeostase solapando o equilíbrio. Assim como tumor se apodera dos tecidos para crescer a gordura se apodera dos alimentos para crescer e dane-se o resto! Por causa disto os termos ser gordo e subnutrido já podem aparecer na mesma frase.

No final dos anos 30 a hipótese da lipofilia estava quase que em alta. Mas desapareceu em 10 anos. A segunda guerra matou, dispersou e desorganizou os pesquisadores adeptos e curiosos sobre a idéia. A paixão nos EEUU pela teoria do “apetite corrompido”, de Newburg, virou religião. Gula e preguiça, dois pecados capitais, se deram as mãos para se inserir no universo de culpa do gordo pecador. Seriam seu pecado original.

Em 1960 a psicologia preponderou e o gordo passou a ter um defeito de caráter, uma variante moral do pecado. Nada mais consequente que a partir daí só a penitência seria o castigo mais adequado. “Irás agora contar calorias com o suor do seu rosto”, poderíamos parodiar. E o gordo sonha com comida assim como sonhamos eroticamente quando estamos em abstinência sexual. O gordo e o padre celibatário devem se penitenciar mas o sonhador erótico não. A psicologia e a religião se unem na teoria sobre como controlar o comportamento “desviante”.

42ª Ilha Bela Sailing Week 2015

http://www.ilhabelasw.com.br/2015/

Quer rimar?

rhymit

Use os serviços do site http://www.rhymit.com/.

O excerto abaixo, da ajuda da ferramenta, mostra a que veio:

Rhymit é um dicionário de rimas para ajudar os artistas, escritores e os poetas a escrever as suas letras de musicas, poemas, e qualquer texto que tenha rimas…Basta entrar no e dicionário de rimas e procurar por uma palavra e o Rhymit tenta encontrar palavras que rimem.

O objectivo é ajudar a expressão cultural a evoluir com a revolução digital, tornando mais eficiente o processo de estruturação de um texto com rimas, no fundo o Rhymit apenas tenta libertar os artistas do processo de pesquisa de palavras que rimem com as suas linhas, tenta ajudar a que os artistas consigam expressar as suas ideias livremente sem se condicionarem demasiado à estrutura de um texto com rimas apenas por não se conseguirem lembrar da palavra certa rimar.

Além de ser uma ajuda para quem já tem alguma fluência a escrever rimas o Rhymit também pode ser uma boa ajuda a quem quer aprender a fazer rimas e tem bastante dificuldade organizar o seu vocabulário de forma a encontrar facilmente palavras que rimem, e assim podem-se manter focados na mensagem que pretendem transmitir ao mesmo tempo que aumentam naturalmente o conjunto de palavras com que conseguem fazer rimas.

O Rhymit ordena as palavras que rimam tendo em conta o número sílabas, isto para facilitar a construção de uma métrica coerente ao longo do poema, e também a facilita a construção de rimas multisilábicas.

Brinquei de poeta só para testar e acabaram saindo os versos na imagem acima (sem nenhum respeito à métrica) ;-)

#SAL_NÓS – Como fazer um lais de guia

Bowline-1010

Descobri no vídeo abaixo que meu Lais de Guia é holandês! Mas pesquisando na Wikipedia descobri que o meu Lais de Guia, com a ponta dentro do laço, é o correto. O “holandês” é o com a ponta para fora (Veja abaixo o nó 1034 1/2 no The Ashley Book of Knots).

Left-Hand Bowline Knot

Cruzeiro a Vela – o “dia seguinte”

Grande sacada  “quase paleolítica”do João Carlos Brito.

O caso deles é típico: depois de 6 anos de trabalho duro o seu veleiro de oceano foi lançado na água. Seis meses depois, o casal iniciou um cruzeiro de “volta ao mundo”. Mas nem tudo correu como o previsto: após seis semanas eles resolveram dar um fim ao seu cruzeiro à vela e colocaram o barco à venda.

(…) A incoerência não é difícil de descobrir. O trio casa-carro-emprego com a sua rotina “de 9 às 17” é comum somente para uma porcentagem pequena da população mundial e está estabelecida há somente algumas centenas de anos. Se isto é realidade, o que aconteceu nos milhões de anos que precederam o nosso século pode ser considerado irreal?

Uma definição alternativa (e melhor) para a realidade pode ser encontrada em alguns de seus componentes….ar….luz do sol….vento….água….o movimento das ondas….as nuvens antes de uma tempestade. Esses elementos, ao contrário da rotina dos escritórios do século 21, estão aqui desde que a vida apareceu nesse planeta e continuarão a exercer a sua influência por muito tempo depois que os escritórios desaparecerem. Eles são percebidos por todos, não somente por um pequeno segmento da nossa sociedade avançada. Usando uma lógica primária, eles são muito mais “reais” do que os estilos de vida transitórios da civilização moderna para a qual os cruzeiristas deprimidos querem retornar.

Se for assim mesmo, concluímos que aqueles que buscam no cruzeiro à vela uma fuga da realidade, cometeram um equívoco na interpretação do que significa “velejar” e “realidade”. Velejar não é uma fuga, mas um retorno para, e um confronto com a realidade da qual a civilização moderna é que se constitui numa fuga. Por séculos, o homem sofreu com a realidade de um mundo que era às vezes muito escuro ou muito quente ou frio para o seu conforto e, para fugir disso, inventou complexos sistemas de iluminação, aquecimento ou refrigeração. O cruzeiro à vela promove um retorno à velha realidade de falta de luz, de calor ou frio. A civilização moderna descobriu o radio, a TV, cinema, bares e uma enorme variedade de entretenimento mecanizado para estimular nossos sentidos e ajudar-nos a escapar do aparente tédio da terra, do sol, dos ventos e das estrelas. O cruzeiro à vela promove um retorno a essa antiga realidade.

Fonte: http://www.veleiro.net/livrodebordo/cruzeiro_a_vela.htm

DAWN I de toldo novo

dawn1-toldo1 dawn1-toldo2 dawn1-toldo3

Shared Bounded Queue in Pharo Smalltalk

PharoScreenshotO método SharedBoundedQueue>>#nextPut: mostrado na figura acima faz parte da implementação de um circular buffer com contenção ou bloqueio de escrita quando o buffer está cheio. A contenção de leitura quando o buffer está vazio é obtida no método abaixo:

SharedBoundedQueue_next

SharedQueue, atualmente usada na implementação de conexões em SmallFBP, só tem contenção na leitura. SharedBoundedQueue também permite uma expansão (Veja os métodos abaixo).

SharedBoundeQueue_grownBy

SharedBoundQueue_packed

Um exemplo usando SharedBoundedQueue foi adaptado de um exemplo num dos posts sobre SmallFBP:

exampleWithClosures

exampleWithClosures2

exampleWithClosures3

Neste pequeno desenvolvimento comecei a experimentar o framework AutoTest. Ele está dentro do espírito do teste contínuo.

Os file outs das implementação e testes de unidade seguem abaixo  e versões futuras podem ser encontradas no repositório de SmallFBP.

Stream subclass: #SharedBoundedQueue
	instanceVariableNames: 'capacity monitor items count start end'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'SharedBoundedQueue'!
!SharedBoundedQueue commentStamp: 'FranciscoAryMartins 6/12/2015 19:56' prior: 0!
I'm a FIFO circular buffer who blocks on empty for readings or full for writings.

I'm a subclass for Stream but implement partial protocol.

Public API and Key Messages

- capacity   
- capacity:
- contents
- grownBy:
- isEmpty
- isFull
- next
- nextPut
- peek
- size

- SharedBoundedQueue capacity: anInteger create a instance with room for anInteger elements.

   One simple example is simply gorgeous.
 
Internal Representation and Key Implementation Points.

    Instance Variables
	capacity:		anInteger
	count:		anInteger
	end:		anInteger
	items:		anArray
	monitor:		aMonitor
	start:		anInteger!


!SharedBoundedQueue methodsFor: 'stream-protocol' stamp: 'FranciscoAryMartins 6/12/2015 19:29'!
grownBy: anInteger
	<require: 'anInteger > 0'>
	<ensure: 'self capacity = old_ capacity + anInteger'>
	monitor
		critical: [ 
			items := self packed grownBy: capacity - count + anInteger.
			start := 1.
			end := count.
			capacity := items size.
			monitor signal 
		]! !


!SharedBoundedQueue methodsFor: 'initialization' stamp: 'FranciscoAryMartins 6/11/2015 12:03'!
initialize
	super initialize.
	monitor := Monitor new.
	items := Array new: capacity.
	start := 1.
	end := count := 0! !


!SharedBoundedQueue methodsFor: 'private ' stamp: 'FranciscoAryMartins 6/12/2015 19:43'!
packed
	^ count = 0
		ifTrue: [ Array new ]
		ifFalse: [ 
			start < end
				ifTrue: [ 
					self isFull
						ifTrue: [ items ]
						ifFalse: [ items copyFrom: start to: end ] ]
				ifFalse: [ (items copyFrom: start to: capacity) , (items copyFrom: 1 to: end) ] ]! !

!SharedBoundedQueue methodsFor: 'private ' stamp: 'FranciscoAryMartins 6/8/2015 22:38'!
capacity: anInteger 
	capacity := anInteger ! !


!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/12/2015 19:28'!
contents
	^ monitor critical: [ self packed ]! !

!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/9/2015 21:29'!
next
	| item |
	"See http://en.wikipedia.org/wiki/Circular_buffer"
	^monitor critical: [
		monitor waitWhile: [ count = 0 ].
      item := items at: start.
		start := start \\ capacity + 1.
		count := count - 1.
		monitor signal.
		item
	]
! !

!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/9/2015 07:56'!
peek
	^monitor critical: [
		count = 0 ifTrue: [ nil ] ifFalse: [ items at: start ] ]! !

!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/9/2015 21:01'!
capacity
	^ monitor critical: [capacity]! !

!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/9/2015 12:59'!
nextPut: anObject 
	"See http://en.wikipedia.org/wiki/Circular_buffer"
	monitor critical: [
		monitor waitUntil: [ count < capacity ].
		end := end \\ capacity + 1.
		items at: end put: anObject.
		count := count + 1.
		monitor signal
	].
	^ anObject! !

!SharedBoundedQueue methodsFor: 'accessing' stamp: 'FranciscoAryMartins 6/9/2015 00:17'!
size
	^monitor critical: [ count ]! !


!SharedBoundedQueue methodsFor: 'testing' stamp: 'FranciscoAryMartins 6/10/2015 17:21'!
isFull
	^monitor critical: [ count = capacity ]! !

!SharedBoundedQueue methodsFor: 'testing' stamp: 'FranciscoAryMartins 6/8/2015 23:53'!
isEmpty
	^monitor critical: [ count = 0 ]! !

"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

SharedBoundedQueue class
	instanceVariableNames: ''!

!SharedBoundedQueue class methodsFor: 'examples' stamp: 'FranciscoAryMartins 6/10/2015 21:01'!
exampleWithClosures
	| maxNumber numbers filter printer dropper integers maxInteger accepteds rejecteds |
	
	self inform: 'Open a transcript for see results'.

   "Components"
	maxNumber := [ :out :value | out nextPut: value ].
	
	numbers := [ :max :out | | count rnd maximum |
		maximum := max next.
		count := 1.
		rnd := Random new.
		[ count <= maximum ] whileTrue: [ | number |
			number := rnd nextInt: 99.
			out nextPut: number.
			count := count + 1 
		]
	].

	filter := [ :in :accept :reject | | integer | 
		[  		
			integer := in next.
			(integer odd)
				ifTrue:  [ accept nextPut: integer ]
				ifFalse: [ reject   nextPut: integer ] 
		] repeat 
	].

	printer := [ :in | | integer |
		Transcript clear. 
		[
			integer := in next.
			Transcript space; show: integer. 
		] repeat 
	].

	dropper := [ :in | | dropMe |
		[  dropMe := in next ] repeat 
	].

   "Connections"   	
	maxInteger := SharedBoundedQueue capacity: 10.
	integers := SharedBoundedQueue capacity: 10.
	accepteds := SharedBoundedQueue capacity: 10.
	rejecteds := SharedBoundedQueue capacity: 10.

	"Network and start"
	[ maxNumber value: maxInteger value: 15 ] fork.
      [ numbers value: maxInteger value: integers ] fork.
	[ filter value: integers value: accepteds value: rejecteds ] fork.
	[ printer value: accepteds ] fork.
	[ dropper value: rejecteds ] fork.! !


!SharedBoundedQueue class methodsFor: 'instance creation' stamp: 'FranciscoAryMartins 6/8/2015 22:43'!
capacity: anInteger 
	| queue |
	queue := self basicNew.
	queue capacity: anInteger.
	queue initialize.
	^ queue! !
TestCase subclass: #SharedBoundedQueueTest
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'SharedBoundedQueue-Tests'!
!SharedBoundedQueueTest commentStamp: '<historical>' prior: 0!
A BoundedQueueTest is a test class for testing the behavior of BoundedQueue!


!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 11:32'!
testNextPutContention
	| q s |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	s := #blocked.
	[ q nextPut: 4. s := #unblocked ] fork.
	Processor yield.
	self assert: s = #blocked! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 12:53'!
testPeek
	| q |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1.
	self should: q peek = 1.
	self should: q peek = 1.! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/11/2015 13:28'!
testGrownByOnMiddle
	| q |
	q := SharedBoundedQueue capacity: 5.
	q nextPut: 1; nextPut: 2; nextPut: 3; nextPut: 4.
	q next.
	q grownBy: 2.
	self should: 7 = q capacity.
	q nextPut: 5; nextPut: 6; nextPut: 7; nextPut: 8.
	self should: q isFull! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 11:32'!
testNextContention
	| q s |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	q next; next; next.
	s := #blocked.
	[ q next. s := #unblocked ] fork.
	Processor yield.
	self assert: s = #blocked! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 21:41'!
testRemoveNextPutContentionWithGrownBy
	| q s |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	s := #blocked.
	[ q nextPut: 4. s := #unblocked ] fork.
	Processor yield.
	self should: s = #blocked.
	q grownBy: 2.
	Processor yield.
	self should: s = #unblocked
! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 21:12'!
testGrownBy
	| q |
	q := SharedBoundedQueue capacity: 3.
	q grownBy: 2.
	self should: 5 = q capacity! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 12:56'!
testSize
	| q |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 1.
	self should: q size = 2! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/12/2015 13:59'!
testGrownByOnFull
	| q |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	q grownBy: 2.
	self should: q isFull not.
	self should: 5 = q capacity.
	q nextPut: 4; nextPut: 5.
	self should: q isFull.
	self should: #(1 2 3 4 5) = q contents
	! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 13:20'!
testIsEmpty
	| q |
	q := SharedBoundedQueue capacity: 3.
	self should: q isEmpty.
	q nextPut: 1.
	self shouldnt: q isEmpty.
	self should: q next = 1.
	self should: q isEmpty.! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/9/2015 13:19'!
testIsFull
	| q |
	q := SharedBoundedQueue capacity: 3.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	self should: q isFull.
	q next.
	self shouldnt: q isFull.! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/11/2015 13:33'!
testGrownByOnMiddle2
	| q |
	q := SharedBoundedQueue capacity: 5.
	q nextPut: 1; nextPut: 2; nextPut: 3; nextPut: 4.
	q next; next.
	q nextPut: 5; nextPut: 6.
	q grownBy: 2.
	self should: 7 = q capacity.
	q nextPut: 7; nextPut: 8; nextPut: 9.
	self should: q isFull! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/11/2015 13:14'!
testGrownByOnEmpty
	| q |
	q := SharedBoundedQueue capacity: 3.
	q grownBy: 2.
	self should: q isEmpty. 
	self should: 5 = q capacity  ! !

!SharedBoundedQueueTest methodsFor: 'tests' stamp: 'FranciscoAryMartins 6/12/2015 19:41'!
testContents
	| q |
	q := SharedBoundedQueue capacity: 5.
	self should: #() = q contents.
	q nextPut: 1; nextPut: 2; nextPut: 3.
	self should: #(1 2 3) = q contents.
	q next.
	q nextPut: 4.
	self should: #(2 3 4) = q contents.
	q nextPut: 5; nextPut: 6.
	self should: q isFull.
	self should: #(2 3 4 5 6) = q contents.
	! !