Categories
UoPeople

Programming 2 concluído e uma dica

Após longa ausência volto para escrever sobre este que é considerado um dos cursos mais difíceis da UoPeople: Programming 2. O terror dos estudantes de Ciência de Computação e alvo constante de perguntas sobre o conteúdo das matérias, quanto tempo investir por semana e como se preparar. Vou tentar, como sempre, abordar tudo isso de forma resumida. Acho que detalhar demais não é produtivo, mesmo porque o conteúdo do curso pode mudar com o tempo. A ideia aqui é compartilhar o conceito do curso e como ele se encaixa no todo de Ciências da Computação.

Seguindo o modelo de Programming 1, trabalhamos com a linguagem Java. Este curso é basicamente uma continuação, um aprofundamento do que aprendemos desde Programming Fundamentals, usando progressivamente os conhecimentos adquiridos para seguir adiante. É nesse ponto que reforço o que falei em postagens anteriores: preste muita atenção nos conceitos básicos! Não há revisão dos fundamentos durante o curso. Pegue suas anotações dos cursos anteriores e revise, preferencialmente antes de começar a unidade 1. 

Em Programming 2 exploramos recursão, estruturas de dados e alguns frameworks disponíveis em Java. Dá para perceber que adoro analogias, e a que faço aqui é que deixamos aos poucos de focar no “trabalho de pedreiro”, executando tarefas focadas e específicas, e passamos para o de projetista, olhando o todo e procurando organizar as diferentes partes de um programa de forma mais robusta possível. Isso fica evidente já na escolha do IDE, migrando do Netbeans para o Eclipse, que possui muito mais recursos e funcionalidades. O uso de Javadoc é requisito básico em todos os exercícios, tornando o uso de comentários claros e compreensíveis uma obrigação e não mais uma recomendação. Logo nas primeiras unidades o foco em Exception Handling (try.. catch) é um aspecto tangível que reforça o que estou apontando.

Conforme as unidades avançam ocorrem várias epifanias, pelo menos foi assim para mim. É maravilhoso ver as peças dos aprendizados anteriores se encaixando em novas figuras, que por sua vez se tornam novas peças e são utilizadas em novos aprendizados. É tão bonito quanto desafiador, e aí está a parte complicada de Programming 2. É o primeiro curso que toca em Análise de Algoritmos, com a notação Big-O, análise assintótica, logaritmos e exponenciais. Para os enferrujados em matemática chegou a hora de tirar as apostilas do colegial da estante, ou mergulhar nos excelentes vídeos do Khan Academy para refrescar a memória.

Nenhum desses conceitos é dado de forma isolada. Recursão e análise de algoritmos tornam-se ferramentas importantes para explorar o conceito de estruturas de dados, tanto de forma abstrata (Abstract Data Types) como implementações específicas (BinarySearch, Linked Lists, Binary Tree). Para quê, quando, onde, como e porquê utilizá-las, assim como avaliar qual estrutura é mais adequada para resolver determinado problema. 

É claro que cada item citado acima dá um curso próprio, e de fato é isso o que teremos mais para frente. Análise de Algoritmos e Estrutura de Dados são tópicos que tomam apenas uma unidade em Programming 2, mas que são também cursos completos mais para frente. Isso porque tanta gente considera esse curso difícil: são vários assuntos complexos juntos e apresentados pela primeira vez. Nesse contexto tive a sorte de ter um ótimo instrutor, Sonnie Avenbuan, que participou ativamente do fórum do grupo, dando dicas valiosas e estimulando as discussões. Ter um bom instrutor fez muita diferença.

Se você está lendo isso com ansiedade, calma, que é só o começo. Agora vem a crítica ao curso, pelo menos em como ele estava estruturado no início de 2018. Ao longo das unidades tratamos das bibliotecas disponíveis em Java. A premissa é boa e faz todo o sentido: não reinventar a roda. Várias estruturas de dados são frequentemente utilizadas e funcionam bem. Devemos entendê-las, mas não é necessário reescrevê-las. Para isso temos classes como ArrayList, LinkedList, Sort, TreeSet, Hashtable e tantas outras, prontas para uso. A sua caixa de ferramentas aumenta consideravelmente durante o curso. Até aí, tudo bom, tudo bem. O problema real surge nas últimas três unidades.

Sou da opinião que poucos assuntos são realmente complicados. O problema costuma estar na didática. Muitas vezes professores, livros ou cursos são mal formulados e fazem pouco para aplicar conceitos abstratos de forma tangível. Em Prog 2 sinto que vivemos os dois mundos. Há exercícios excelentes que conectam perfeitamente o tópico da unidade num projeto prático. Um exemplo é o laboratório de Exception Handling, que nos faz refatorar um código simples para torná-lo mais robusto a erros por parte do usuário. Outro é o laboratório da unidade 4 sobre a Comparable Interface, que faz um uso inteligente do depurador do Eclipse para localizar e corrigir erros em um código de busca e ordenação. Excelente exemplo de exercício prático que simula tarefas realizadas no mundo real.

Infelizmente perde-se o ritmo quando entramos na unidade 6: Files and Networking, Advanced GUI Programming. O título da unidade fala por si. Como é possível trabalhar manipulação de arquivos, redes e interface gráfica em apenas uma semana? Spoiler: Não é possível. O resultado é uma unidade confusa, com excesso de leitura, laboratórios, discussões e learning journals desconectados um do outro e a sensação de que tudo foi organizado de última hora para preencher uma lista de tópicos. Vou citá-los aqui só pela poesia: close(), flush(), streams, ServerSocket, antialiasing, canvas, icons. Tudo. De. Uma. Vez.

É quando você está exausto, na reta final da maratona, e os últimos cinco quilômetros são uma subida íngreme, que a técnica se perde e o único objetivo é chegar vivo e tropeçando até a linha de chegada. Assim são as duas últimas unidades sobre Graphic User Interface (GUI), o que é uma pena, pois o tópico é importante e conecta muito do que aprendemos desde Programming Fundamentals. Ainda assim os aprendizados profundos continuam: relação entre Programação Orientada a Objetos e GUI; composição de imagens (frame buffer) e sua manipulação pela placa de vídeo; Action, Toolbar, Buttons; o padrão Model-View-Controller (MVC) que estrutura os componentes gráficos na biblioteca Java Swing; padrões de design e sua aplicação em classes de interface.

O que salva as últimas unidades são os labs (exercícios de programação) que exploram a modificação de programas já criados. Para mim foram os primeiros exercícios de programação representando efetivamente trabalho prático na área. Isso ficam ainda mais evidente por serem exercícios sobre interface gráfica, onde observamos visualmente os resultados das mudanças e aprimoramentos no código. O exercício da unidade 6 foi um dos mais complicados do curso. A parte positiva de cobrir tantos assuntos diferentes foi a oportunidade de avaliar quais assuntos despertam mais ou menos meu interesse. Interface gráfica, por exemplo, não é minha praia. Foi bom reconhecer isso através de exercícios práticos.

Mas deixei o principal aprendizado, sob a perspectiva dos estudos, para este penúltimo parágrafo. Ao revisar minhas anotações fica claro que meu método de estudo na época era pouco efetivo. Anotei muita coisa sem saber o que é prioridade. Alguns fichamentos têm mais de 25 páginas numa unidade com 100 páginas de leitura! Isso não é razoável. O maior problema sem dúvida foi seguir os materiais de forma “linear”. Começar pelo Learning Guide, seguir para os Reading Assignments, e assim por diante. Faz muito mais sentido seguir para o Self-Quiz logo após terminar os Reading Assignments, anotar os tópicos do Discussion e do Programming Assignment e usar isso para fichar os materiais apenas nos pontos que realmente importam.

Programming 2 é um curso desafiador, mas é efetivamente o curso-base de Ciência da Computação que toca superficialmente nos tópicos centrais que serão revisitados em vários cursos avançados. É normal não entender tudo de uma vez e fazer vários exercícios sem muita ideia do que está acontecendo. Absorva tudo o que for possível, mas saiba que esses assuntos serão tratados com mais calma adiante. Não se afobe! Para facilitar, recomendo fazer Prog2 sozinho, a não ser que você estude na UoPeople de forma integral. Faça com calma e atenção que sem dúvida seu aprendizado será efetivo.

Qualquer dúvida é só comentar ou entrar em contato. Bons estudos!

Categories
UoPeople

Polimorfismo em Java

Na unidade 6 do curso de Programação 1 aprendemos o conceito de polimorfismo, termo derivado do grego poli — muitos —, e morpheus — forma, estrutura. Uma das tarefas é discutir polimorfismo no contexto de programação orientada a objetos e dar um exemplo de como implementar essa funcionalidade em Java.

Revisando as anotações achei que a minha abordagem foi interessante. Segue para a apreciação, com pequenas modificações.


The world around us is polymorphic. We can see this almost everywhere: people, animals, cars, books, languages, houses. As humans, we seek to differentiate ourselves from others. We like to think and show that we are unique up to a point in which other people still recognize us as humans. Up to a point that they still can relate and interact with us.

Something similar happens with a programming language like Java. The ability to instantiate and handle multiple objects together make complex programs easier to handle, manage and develop. It is expected that complex software keeps evolving and including new functionalities with time. Imagine that if for each new functionality you have, you need to review previous objects and update old code to fit each new features included. It can easily become a complex and time-consuming task. Polymorphism is a powerful solution that avoids a lot of code rework and guarantee program fluidity. Citing Oracle Java documentation definition, “subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.” (Oracle, 2017)

Imagine the following Language superclass and English subclass.

class Language {
    void toHear(Language hear) {
    // Method to hear some language
}
toSpeak(Language speak) {
    // method to speak some language
    }
}

class English extends Language {
	void toHear(English hear) {
	// specific instructions to hear and understand the English language.
	}
	toSpeak(English speak) {
	// specific instructions to hear and understand the English language.
	}
}

Imagine that in the example above you have multiple language subclasses and want then all to “work” in their own language. Of course that this is a simplified example, but the same method toSpeak would call a specific response for each object (aka each language), a unique behavior, while still sharing some functionality from the parent class.

Reference: Oracle (Ed.). (n.d.). Polymorphism. Retrieved October 18, 2017, from https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html

Categories
UoPeople

Programming 1 – Learning Journal

Escrevi isso no diário de classe de Programming 1 na University of the People. Idos de 2017. Estou revisando minhas anotações para o texto sobre o curso e achei interessante compartilhar isso aqui em separado. Segue.

Learning Journal – Unit 4

The process of developing a program with subroutines was very enlightening to me in the overall programming learning process. If in the Programming Fundamentals course we were presented to conceptual models like flowcharts and pseudocode, now we actually use the tools that break the problem into manageable steps and make complex ideas possible to handle.

I know that it can be a naive feeling, but it is a realization that programs are simpler than I originally imagined. Not in the sense that they are easy. Now it is also much more clear to me the amount of effort behind complex software and systems. But they are done in manageable steps. There are several foundations done many years ago that are still used as the basis to systems that are developed nowadays. I do not remember quite well where I read the phrase from one of the Unix OS developers that was surprised by seeing lines of his code in almost every operating system that we use today.

There is this concept of the human colossus: the realization that we build everything on the shoulders of many scientists and inventors that came before us. Being a “genius” in that sense is always a humble process. Humanity is a collective effort and somewhat this is especially intense when we study software development.

As you can see, my feelings on this unit are more philosophical. Routines and subroutines building on top one of another. Black boxes and the recognition that a lot around us have mysterious internal dynamics that we simply do not think about, just trust, use, and even put our lives on its hands. This makes me understand the importance of the work that I might decide to do and the projects that I might get involved in the future. In our times, lines of code can save many lives, but they also can kill many. If in the last learning journal I talked about the importance of studying math to be a better developer, now I see the importance of philosophy and ethics behind what we do and the tools that we have at our disposal. It should not be only about a good job and salary. I must be about us all, the humanity and the human colossus.

Categories
UoPeople

University of the People no Brasil

Amanhã começa o período 1 de 2017 na University of the People (ou UoPeople para os mais chegados). Será meu sexto período desde que comecei a cursar Ciência da Computação em junho de 2016. Com 18 pontos de crédito ainda sou considerado “calouro” de acordo com o catálogo da universidade. O caminho para percorrer ainda é longo.

Desde que comecei o curso me chamou atenção a baixa quantidade de estudantes brasileiros envolvidos e o interesse estável no Brasil. De 2016 para cá vi pouca diferença nas comunidades internas da faculdade e no grupo de estudantes no Facebook. As matérias sobre a universidade em português são raras e a maioria é de mais de ano. Acredito que o inglês seja uma barreira para muitos, mesmo assim temos um potencial muito maior de envolvimento considerando nossas dimensões e população.

Essa é a segunda tentativa que faço de criar um blog pessoal para compartilhar meus estudos, discutir assuntos de aula e do mercado e estimular a comunidade de estudantes brasileiros em cursar uma faculdade à distância no exterior. Com um pouco mais de ambição espero que esse espaço se torne um dos muitos agregadores de discussões e projetos. Não faz sentido cursar uma universidade sem motivo, sem uma razão construtiva. Que esse espaço sirva de catalizador para mim e para colegas na longa e árdua jornada do estudo superior online à distância.

É comum começarmos projetos cheios de ideias, estrutura, pré-requisitos e afins. Sinceramente minha experiência passada mostrou que excesso de planejamento paralisa. Meu objetivo desta vez é manter as coisas simples, atualizar diariamente e fazer melhorias aos poucos. O primeiro passo é importante, porém constância é essencial.

Bem-vindos!

Para saber mais sobre a universidade recomendo os links abaixo:

University of the People – http://www.uopeople.edu/

Grupo de Estudantes da UoPeople no FacebookLink