PotHix - tech

Using a 10yo phone (Nexus 5)

Unknown — Mon, 16 Oct 2023 00:00:00 +0000

I decided to change my phone to a newer hardware. While changing hardware, I would have to do a little dance of devices:

Move whatever I have in my phone to another device
Do a factory reset on my current phone
Give it to my wife
Get her phone and do a factory reset before sending it for a battery change

That means I would need a third device while I don't have my new hardware. For that, I have a very old Nexus 5 phone and decided to try it out.

I was doing it for a few reasons:

The device was still working, so why not?
How would it be to use a 10 years old phone nowadays?
How updated can I make this device?
Feeling a bit nostalgic about installing custom android ROMs 😂

So... why not? 🙂

Preparing the hardware

A few months before, I bought a new battery and case for it on Aliexpress. It was cheap enough to worth it. My plan is to give this phone to my children when needed. If they drop and it breaks, it's fine (it's a 10yo anyway).

The new case already gave the phone a fresh new look. The new battery gives the phone half a day of life if I'm being careful about the power consumption

I decided to open it and clean the inside with isopropyl alcohol, just to be sure buttons would not be sticky. Which was already a symptom.

After that, the phone looked new.

Preparing the software

I was running a very weird custom Android, but the good news is that it was already prepared for custom ROMs.

The first step is to factory reset it and go for the new Android. I'm not going to repeat the whole process here and instead will recommend this great article a friend mine wrote. I just followed what is written there and it was done.

In summary, for the curious but lazy:

Install an updated version of TWRP that can repartition the phone
Repartition the phone (much easier than what I expected)
Download the most updated version of Android for this phone
- Turns out the only one I found is an image a random guy is kindly maintaining for years. Sill supports Andorid 11 and works great.
Install it as you do with any custom ROM

That's it! Nexus 5 works as it should.

How is it to use an old phone like that?

You have to be patient with the oldie. 😅

It works most of the time, but it's not very powerful for the current world. You have to do most things very slowly for it to catch up.

I was mostly relying on the power saving feature of Android to avoid greedy apps to wake up and consume power quickly. By doing that, I could keep the phone on for more than half a day. The problem comes when I disable the power saving and all apps decide to do their thing at the same time. It usually takes a few minutes for the phone to be responsible again. 😅

You have to learn to deal with "unresponsible apps". Most of the time, it's not a problem, it's just the hardware being too slow to respond. You have to tap "wait" instead of closing the apps.

I used this phone during an international trip. It was a bit risky, but also an interesting experience. I just needed it to work for a few days, and it did not disappoint. :)

For science

This was the perfect opportunity to see how much a phone can still be useful after years and it turns out this phone was very useful if you're in right mood.

It's not recommended to use it as a primary phone, but certainly a usable phone in case you need it temporarily or for some very specific task.

I also used this opportunity to test Todoist under these circunstances. The team asked to test certain features we are developing to see how it's going to work under stress like that. The results were interesting.

Hardware problems

Let's be real, it's a 10yo device. Of course I will have hardware problems at some point.

It's quite common for the Nexus 5 to have a button stuck. Sometimes it's the power button, which makes the phone to keep rebooting. Sometimes it's the volume button, which makes the phone always start in safe mode (power + volume down goes to recovery).

Everything worked well enough during my trip (thankfully!), but the device started showing problems with the volume down button when I arrived at home. This effectively made the device unusable, as it was in safe mode all the time.

The solution for that is to change the button (video), but I don't have a replacement here (yet!). My solution was simple:

Who needs a volume down button anyway? 😂

After trying may different ideas, I had to remove the button and everything was back working.

For a while... now the other two buttons are showing the same problems, so I will have to wait for the replacement buttons to arrive so I can fix the phone before giving it to my children as a playing device.

Conclusion

Don't throw your devices away, they can still be useful after 10 years! If you're up for the task, it can be useful and fun! Enjoy!

StrangeLoop 2023

Unknown — Thu, 12 Oct 2023 00:00:00 +0000

I've been following the StrangeLoop conference for about 10 years now. Watching some of the talks online, talking to friends who had the chance to attend in the past, and following the news from time to time.

This year's edition would be the last one. When a friend of mine told me that, I decided to make an effort to participate. It is a long trip to get to St. Louis (~16 hours, door to door), but it would be worth it.

Below are my notes from the talks I attended. These are mostly raw notes, so you're reading them raw as they come from my understanding watching the talk. I didn't have that much time to review everything. 😅

First day:

How to have a meaningful career

Nice talk. I like these kinds of talks that inspire you more than teach you one or two commands or tricks in your favorite programming language.

Everyone is an expert in something. I'm an expert in my own journey.
Give yourself grace, even in hard moments.
- To give myself some grace, I took a sabbatical.
It's the "L"s that make us
- The guy was ranting about HTTP to the guy who wrote the specifications
Luck = opportunity+being prepared
Scott hanselman (Microsoft) once had a presentation and two people showed up because Linus was speaking nearby.
Two things can be good at the same time, you may be there for the money and be passionate about it.
Technical resilience: do the job and persist
Your task is not to foresee, but enable it -- Antoine de St Exupery
Growth happens when you're stretching not when you're drowning. It's OK to deal with things that are more than you can handle, but just the right amount.
She is speaking at the last conference she loved and attended for so many years.
If you find meaning, and it's important to keep moving in that direction.

Playing with Engineering

Another inspiring talk, especially for people who have kids. She shows that engineering can be fun in many different ways, and this is her research.

Talk by AnnMarie Thomas
Playful learning lab
Professors in STEM don't have training into actually teaching and the psychilogof it.
Play is about process, not the outcome. Play involves freedom of choice. it's often social.
Instead of using a soldering iron, she teaches her daughter with dough that conducts electricity
You can find sounds in everything. Looking for sounds in the house.
"OK go sandbox" playlist on Spotify
Play is about process, not the outcome.
How can I create an engineering culture hat my kids want to be in?

The Attacker Has Expensive Radio Equipment, But Your Android Phone Is Resilient

Stop what you're doing and disable 2G from your phone right now. 😅 Yomna shows the problems with radio protocols, especially the old ones. Your phone probably still supports the old protocols, so there's a good chance you're still vulnerable. The talk was nice.

A view on implementing android radio security
Cell towers, BTS, etc.
GSM (2g) LTE (4g). We will call GSM.
AOSP (Android open source project)
OEM (Original equipment manufacturers), companies who ship hardware with android
Bands of frequencies are pre-programmed in the SIM card, they are searched first.
IMSI is the unique identifier of your SIM card. Must be kept private.
TMSI is a temporary location identifier when connecting to a tower.
The phone is not always connected, it's mostly on idle mode waiting for the trigger to "wake up".
In 2G, some clients even use a NOCIPHER, to not have encryption.
Atlas of surveillance. org
Swearing trojan from China (2017) - Link I read in the internet: https://www.linkedin.com/pulse/chinese-hackers-use-fake-cellphone-tower-spread-stu-sjouwerman/
Broadcast of SMS may not be authenticated and attacks happen.
Phones that still accept 2G are vulnerable. Android has a "Allow 2G" option that can be disabled.
In AOSP, the hardware/interfaces/radio/1.6 directory contains the code to handle versions.
yomna.net

Lessons from building GitHub Code Search

This is probably the talk I liked the most. Luke was able to clearly describe the problem they had, and why the architecture was not enough for it. He showed the research they did and how they approached the problem step by step.

On each of those steps, he described what the problem was and how they evolved the infrastructure to deal with it.

The solution looks great, and the lesson for me is to think about your solution in a scalable way. Do it to solve a smaller version of the problem and iterate over it to fix bigger problems. Be sure you can change/rewrite/add more small pieces of the solution.

Talk by Luke Francl
https://github.com/look/lessons-from-ghcs
Blackbird is the name of the search engine
The goal of the system is to ask programmer's questions
We rewrote it in rust 🦀
Blackbird crawler is written in Go
We use Kafka for message queue
The cost for the CS cluster costs 4.5MM
Lessons
- purpose built software can make sense. Creating a search engine from scratch is complicated, but was worth it.
- Every level f scaling bring new challenges
- Designing for change is hard. It takes a lot of effort to make your system easy to change. If you can, design your system to be malleable.

Risks and Opportunity of AI in incident management

I went to this talk to understand what was the idea behind the topic. I found it to be too abstract. It was more related to ideas on how to use AI and how it can contribute. Not really my kind of talk.

Emily Arnott
Maybe in an incident response, we should ask questions that are not formhumaes. Some very specific questions.
Everything that is pulling you away from your plans must be planned accordingly.
Challenges
- It is time sensitive
- expertise requeriment
- coordination and communication
Things to be careful about
- black box
  - They don't know anything specific
- hallucinations
  - Some answers don't really make sense. Give everything another layer of sanity check.
- Desynchronization
  - The model is not updated every day.
Build a blameless culture for incidents
Empower engineers with strategic perspective on how to use AI to enhance themselves
Train engineers in AI operations and let them experiment with it.
You need a robust and resilient process
The benefits of AI has nothing to do with downsizing, it just helps a bit
Risks
- Technical debt with AI
- Weird new bugs
- Alienated engineers who can't use the new tools
blameless.com/author/emily-rnott

Written comedy with generative models

I don't have that many notes on this one, but it was A-M-A-Z-I-N-G. I really recommend you to watch this video. It's not the kind of talk you learn a ton of new tricks, but it's the kind of "programming art" that really brings back everything that brought me to programming.

The talk was interesting and fun. Definitely worth watching.

Is predictive text a makov chain?
small models, small data and simple n-gram models
Tokenization

The level of human involvement behind remote desktop protocol brute-force attack

This talk was less technical and more about the human interaction on the attach. The did the setup of a honeypot and did some research on it. It was nice to see the results of such a technique, but not very technical.

Andreanne bergeron
They used honeypots for RDP and collected 13 million attempts
3427,611 attacks. 1.5k IPs
50% of the attacks came from Asia (Russia was clarified as Asia, and most are from Russia). Russia, HK, and Panama.
They created a fake company to the honeypot and attackers used specific usernames related to that company.
Users did some research before doing the brute force and tried specific Digital Ocean tooling names.

Second day

Playable quotes for gameboy games

I really liked this one too. You can see the results at tenmile.quote.games

They added a way to record playing games in NES emulators. They were able to do that adding one line of code to the emulator to inject code that inspects memory. The fact that they can add metadata to the screenshot of the game and use it to import the quote and replay it is awesome. Such a great and fun research. Definitely worth watching.

Stenographically encoded pixels in the image. Its a zip file of 5 different things.
A quote has the game rom, buttons pressed, save state, and a readme.
Interactive tour m2.quote.games
They used Binaryen to change memory

Economics of programming languages

Talk by the creaor of Elm. I was always curious about the creation of new languages and how to earn money from it. It was interesting to see his perspective on the topic (from experience) and analysis on different programming languages and companies. Definitely an interesting topic and talk.

Working on a programming languages was all intrinsic motivation
Who pays for these?
Progress and poverty book recommendation
Traffic aquisition cost is very significant for Google. Its important for the company to be everywhere
The open source way
- You solve a problem yourself and give it away
- Other things slowly come "for free" with people and intrinsic motivation. A lit of work to get to that though
Independent languages
- Recruiting
- Consulting: which also takes the time from language work
- Research grants
- Editor licences
- Hosting
- Donations
Design incentives
- Add features? Yes: less conflict, NO: less complexity
Patronage
- Your job serves the purpose of a powerful person. What is it? What if it changes?
- Working hard is not enough if you're not aligned to "the goal"
Donations
- People donate for their own personal reasons
- "ill donators approve this?"
Hosting
- People use the service because is suits their needs.
- "Will it be easier to make websites"
For authors: "The open source way" is for businesses
For language users: What are the goals of this language? What is the situation of the author? The trade offs suit your needs?

Unmasking the Godfather - Reverse Engineering the Latest Android Banking Trojan

It is literally a reverse engineering of a trojan. Not many notes on this one, but it was interesting to see the trojan working and how it tricks the user to enable some kinds of features it needs. A bit eye openining on the technology side and also in the user side.

The malware keeps asking for accessibility services, create fake HTML pages when they detect important pages, steal credentials for the user

A Long Strange Loop

It was a great talk for me, personally. I organized conferences in the past and plan to do it again. Listening to his experience during these 10+ years was quite insightful.

The talk was also very emotional because it's something he is doing for more than 10 years out of love. You can clearly see that. Leaving it behind is a bit emotional.

I also have a feeling that it is becoming harder and harder to make the conference sustainable, given the history of past conferences he shared. The pandemic made this even worse too.

Well, it was great to watch this and be able to be part of the crew given a standing ovation to the organizers.

Started in 2009
2008, peak time for meetup
"I am a strange loop - Douglas Hofstadter"
He wanted to connect people in a place he liked. His Uncle id that before.
Important talk feedback
- Every talk in the conference was in the list of favorite talks
- multi-tracks are good
- match expectations
Thrown for a loop (2013)
- There was a teatrical piece and a presentation by Douglas Hofstadter.
"The people are here. This is the conference"
The grant program was very rewarding. They paid for people's hotel, conference, etc.
Risks
- signing contracts in advance
- natural disasters
- human disasters (terrorism, etc.)
What is he future?
- We have a big carbon footprint to fly everyone here
Virtual conferences
- When you are in a virtual conference, you don't have your "third place", you're usually at home or work.
- Doing talks is hard, doing remote talks is even harder.
- Maybe VR an help a bit n the future, but I'm not sure.
- Is there something in between?
  - There are places for people to meet locally, it would be a way to unite them. Maybe a local conference? Company?
  - Async conference. People make local conferences and share with other groups. 💭 that's an interesting idea I'm going to think about
Why is it ending?
- It achieved everyone I want t to achieve.
- It got harder and riskier to do these events. Is this the year I'm going to go bankrupt?
- Strange Loop has a point of view, and etsmy point of view. If someone takes the conference, it will be a different conference. I can totally let you know everything I know if you want to do something like this.
- It's OK for things to end.

Making Hard Things Easy

This is the talk by Julia Evans. I've been following her work for many years, as I wrote the Desconstruindo a web book, which has a similar idea of her zines.

It was a fun talk and I learned a lot of small things that can go wrong with tools we use all the time. Definitely recommended.

DNS shouldn't be so hard. Everyone is having the same probueover and over again.
Bash does not stop. set -e to make it stop when there's an error
shellcheck
Share tools you're using to reduce cognitive load
Finding the right references is not easy
Understanding the whole process is a great activity to do with coworkers

Drawing comics at work (no video yet)

This is a talk by the creator of the Xkcd comics. It was a fun talk. Did not learn a lot, but it was interesting to learn more about how xkcd came to life and became something most developers know and love. There are also some cool stories behind the scenes.

He had a talk at Google and got questions about Python by Guido and algorithms by Donald Knuth
He is a physicist and was contracting with NASA before XKCD
He created the "someone is wrong in the internet" as a satire for himself and other people doing the same.
The playballs comic was a thought that became comic. Someone actually did it nd he tried too!
I got Serena Williams to try to drop a drone
I got responses from experts in many fields and many fun people.
Chris Hatfield was interviewed by Monroe
"You can write a good book even if your keyboard layout is not optimal" 😂

Post-conference

There's one famous happy hour they do after the first day when people visit the city museum, which is amazing.

They also had some sort of happy hour after the second day of the conference, and I used this time to meet new people.

I met a few people and randomly joined a group that was forming to discuss local-first software. We discussed CRDT, automerge, the ideas shared by Martin Kleppmann on his talk about collaborative text editing and Upwelling, and some personal experiences with projects we're working on.

It was fun that I joined this group because I could share some experiences from Todoist, which is a local-first app for many years.

Conclusion

It was a great conference. I'm glad I had the chance to attend it. It was expensive and I'm glad the company I work for help me to attend these, otherwise, it would be quite complicated for me to go there. ❤️

How typing speed influences our life

Unknown — Sat, 05 Feb 2022 00:00:00 +0000

It's not the first time I have an argument with someone about typing speed, so I decided to write this small post to make my point clear.

The discussion usually starts with the following argument:

I don't have to type fast to be a good programmer. Programming is not about typing, but thinking about the solution.

Yes, that's true! The whole job of a programmer is not to type, but to solve problems. Typing faster will not make you a better programmer. What makes you a better programmer is actually... programming!

With that said, you spend a big portion of your day typing stuff. Typing code faster is useful, but I'm not even talking about the code itself, but everything else.

Just to list a few things:

Emails
Group chats (Twist, Slack, Discord, whatever you're using)
Writing specs or RFCs
Writing good PR descriptions
Writing PR review comments
etc.

Each of these will depend on you to type stuff. Having a faster typing speed will definitely make you more productive. You don't have to be the fastest typist around, but typing less than 80 words per minute is totally something you should consider improving.

I like to build mechanical keyboards (ref1, ref2) and I take ergonomics very seriously. I also use a different keyboard layout to make my typing more ergonomic, but you don't need any of that type fast enough.

You can be a faster typist using your laptop keyboard and qwerty, you just need to practice. Just post is here to cut the excuses about typing. Typing fast enough is important. ✌️

Review of Software Engineering at Google

Unknown — Tue, 28 Sep 2021 00:00:00 +0000

Book: Software Engineering at Google: Lessons Learned from Programming Over Time by Titus Winters. Rating: ⭐️⭐️⭐️⭐️.

It was a great book to read. It's not the kind of book you read and start applying stuff at your current job. We all must remember we're not Google, and many things mentioned there are great, but only applies to their context.

With that said, I quite enjoyed the book. I was curious about Google's structure, and it's mind-blowing the amount of problems specific to that scale. I even learned a few things that are still worth applying in non-Google companies.

I have to say, the whole chapter about testing is very on point to me, they nailed it, not just for Google. Things get even more complicated in Google's scale, but most of the conclusions and processes there would resolve a bunch of problems in other pieces of software I had to work with during my career.

Here are my raw notes about the book (quotes and my comments after 💭):

1. What is Software Engineering
- Programming Over Time
  - One key insight we share in this book is that software engineering can be thought of as “programming integrated over time.”
  - Nothing is built on stone; all is built on sand, but we must build as if the sand were stone.
    - 💭 — This is so true in software development
  - One way to see the impact of time on a program is to think about the question, “What is the expected life span1 of your code?”
  - Your project is sustainable if, for the expected life span of your software, you are capable of reacting to whatever valuable change comes along, for either technical or business reasons.
  - When you are fundamentally incapable of reacting to a change in underlying technology or product direction, you’re placing a high- risk bet on the hope that such a change never becomes critical.
  - The job of a software engineer, or a software engineering leader, is to aim for sustainability and management of the scaling costs for the organization, the product, and the development workflow.
  - We might sometimes defer maintenance changes, or even embrace policies that don’t scale well, with the knowledge that we’ll need to revisit those decisions. Those choices should be explicit and clear about the deferred costs.
- Time and Change
  - A serial startup developer could very reasonably have 10 years of development experience and little or no experience maintaining any piece of software expected to exist for longer than a year or two.
    - 💭 — That is an interesting point. I've been working on long lived apps in the past 10 years and I certainly dealt with some developers that introduced bad code because of such mindset
  - keeping software maintainable for the long- term is a constant battle.
  - With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody.
  - Given enough time and enough users, even the most innocuous change will break something;
  - Per Hyrum’s Law, programmers will write programs that depend on the order in which a hash table is traversed, if they have the ability to do so.
    - 💭 — It reminds me of JSON comments. LOL
  - But even this still allows for some Hyrum’s Law surprises: there is code that uses hash iteration ordering as an inefficient random- number generator. Removing such randomness now would break those users.
    - 💭 — LOL
  - We’ve taken to saying, “It’s programming if ‘clever’ is a compliment, but it’s software engineering if ‘clever’ is an accusation.”
    - 💭 — That's interesting and I can clearly see examples where this applies throughout my carreer
  - the ever- widening gap between CPU cycles versus memory latency impacts what “efficient” code looks like. Over time, the value in upgrading to newer hardware can be diminished without accompanying design changes to the software.
- Scale and Efficiency
  - if changing something comes at inordinate cost, it will likely be deferred.
  - Only with an organization- wide awareness and commitment to scaling are you likely to keep on top of these issues.
  - We’ve found that expertise and shared communication forums offer great value as an organization scales. As engineers discuss and answer questions in shared forums, knowledge tends to spread. New experts grow. If you have a hundred engineers writing Java, a single friendly and helpful Java expert willing to answer questions will soon produce a hundred engineers writing better Java code.
  - The more frequently you change your infrastructure, the easier it becomes to do so.
  - No single process or tool needs to be perfect, so we can assume a defense- in- depth approach, hopefully catching as many defects on the left side of the graph as possible.
- Trade-offs and Costs
  - If your project life span is short, forks are less risky.
  - Contrary to some people’s instincts, leaders who admit mistakes are more respected, not less.
  - Every task your organization has to do repeatedly should be scalable (linear or better) in terms of human input.
1. How to Work Well on Teams
- Hiding Considered Harmful
  - When you become stuck on something absurd, how much time do you waste pulling yourself out of the hole? Think about how different the experience would be if you had a couple of peers to look over your shoulder and tell you— instantly— how you goofed and how to get past the problem.
    - 💭 — This is an important topic in a remote and asyc work environment. It's indeed slower but the focus is usually higher in a remote environment .
  - Don’t misunderstand us— we still think engineers need uninterrupted time to focus on writing code, but we think they need a high- bandwidth, low- friction connection to their team just as much. If less- knowledgeable people on your team feel that there’s a barrier to asking you a question, it’s a problem: finding the right balance is an art.
- It’s All About the Team
  - You need to work with other people. Share your vision. Divide the labor. Learn from others. Create a brilliant team.
    - 💭 — This is something I can relate to. You don't need to be in the same place or be talking real time to do that
  - If you perform a root- cause analysis on almost any social conflict, you can ultimately trace it back to a lack of humility, respect, and/ or trust.
  - The discussion stays focused on the code itself, not on anyone’s value or coding skills.
  - The more open you are to influence, the more you are able to influence; the more vulnerable you are, the stronger you appear.
  - Sometimes, the best thing you can do is just say, “I don’t know.”
  - your organization needs a culture of learning, and that requires creating the psychological safety that permits people to admit to a lack of knowledge.
1. Knowledge Sharing
- Philosophy
  - Documented knowledge, on the other hand, can better scale not just to the team but to the entire organization.
  - Tribal and written knowledge complement each other.
- Growing Your Knowledge
  - Seek out and understand context, especially for decisions that seem unusual. After you’ve understood the context and purpose of the code, consider whether your change still makes sense. If it does, go ahead and make it; if it doesn’t, document your reasoning for future readers.
- Scaling Your Questions: Ask the Community
  - Do your future self a favor: when you learn something from a one- to- one discussion, write it down. Chances are that future newcomers will have the same questions you had. Do them a favor, too, and share what you write
  - Leaders improve the quality of the people around them, improve the team’s psychological safety, create a culture of teamwork and collaboration, defuse tensions within the team, set an example of Google’s culture and values, and make Google a more vibrant and exciting place to work. Jerks are not good leaders.
  - go/ links are so short that it’s easy to share them in conversation (“ You should check out go/ frobber!”).
    - 💭 — It's Interesting that I just did this with my blog and can confirm it's useful.
- Readability: Standardized Mentorship Through Code Review
  - one or more qualified reviewers must explicitly give readability approval for the CL.
    - 💭 — I can imagine how bureaucratic this is...
1. Engineering for Equity
- Understanding the Need for Diversity
  - Engineers should begin by focusing all work within the framing of the complete ecosystem they seek to influence.
  - Diversity is necessary to design properly for a comprehensive user base.
- Reject Singular Approaches
  - A common methodology today is to build for the majority use case first, leaving improvements and features that address edge cases for later. But this approach is flawed; it gives users who are already advantaged in access to technology a head start, which increases inequity.
  - This research should be done with user groups that are multilingual and multicultural and that span multiple countries, socioeconomic class, abilities, and age ranges. Focus on the most difficult or least represented use case first.
- Values Versus Outcomes
  - Design for the user who will have the most difficulty using your product.
    - 💭 — In other words: start thinking on the edge cases instead of the happy path. It may be feasible to a large company like google but i wonder if this is feasible for the large majority of small companies.
  - The whole concept of MVP is also made much harder.
1. How to Lead a Team
- Managers and Tech Leads (and Both)
  - Most TLs are also individual contributors, which often forces them to choose between doing something quickly themselves or delegating it to a team member to do (sometimes) more slowly. The latter is most often the correct decision for the TL as they grow the size and capability of their team.
  - Managers and Tech Leads (and Both) > Page 120
  - At Google, it’s customary for larger, well- established teams to have a pair of leaders— one TL and one engineering manager— working together as partners.
  - A Manager is a leader of people, whereas a Tech Lead leads technology
- The Engineering Manager
  - Traditional managers worry about how to get things done, whereas great managers worry about what things get done (and trust their team to figure out how to do it).
  - A good way to build a culture in which risk taking is accepted is to let your team know that it’s OK to fail.
- Antipatterns
  - If it’s permanently necessary to micromanage people because you don’t trust them, you have a hiring failure on your hands.
1. Leading at Scale
- Always Be Leaving
  - This is what good management is about: 95% observation and listening, and 5% making critical adjustments in just the right place.
  - Anchoring a team identity to a specific solution (“ We are the team that manages the Git repositories”) can lead to all sorts of angst over time. What if a large percentage of your engineers want to switch to a new version control system? The team is likely to “dig in,” defend its solution, and resist change, even if this is not the best path for the organization.
1. Measuring Engineering Productivity
- Selecting Meaningful Metrics with Goals and Signals
  - if you look only where you can see, you might not be looking in the right place.
- Taking Action and Tracking Results
  - We instead always assume that engineers will make the appropriate trade- offs if they have the proper data available and the suitable tools at their disposal.
1. Style Guides and Rules
- Creating the Rules
  - At Google, where the style guide serves as law for coding practices, we do not ask, “What goes into the style guide?” but rather, “Why does something go into the style guide?”
  - When a codebase is internally consistent in its style and norms, engineers writing code and others reading it can focus on what’s getting done rather than how it is presented.
  - We know that some of the rules in our style guides will encounter cases that warrant exceptions, and that’s OK.
  - As adoption spreads, engineers wanting to use the new features in different ways discuss their examples with the style guide owners, asking for allowances to permit additional use cases beyond those covered by the initial restrictions.
    - 💭 — That feels very frustrating
  - There are absolutely best practices left unspecified by these documents, including many fundamental pieces of good engineering advice: don’t be clever, don’t fork the codebase, don’t reinvent the wheel, and so on.
  - Noticing when a rule is ready for another look is an important part of the process that keeps our rule set relevant and up to date.
  - problems are proven with patterns found in existing Google code. Given a demonstrated problem, because we have the detailed reasoning behind the existing style guide decision,
- Guidance
  - This “Tip of the Week” series has been extremely successful internally, with frequent citations during code reviews and technical discussions.
- Applying the Rules
  - when it comes to checking for compliance, rather than exclusively depending on engineer- based verification, we strongly prefer to automate enforcement with tooling.
  - Other rules are social rather than technical, and it is often unwise to solve social problems with a technical solution.
  - Reviewers can (and do) push back if they judge a change to be too large. For this and similar rules, enforcement is up to the discretion of the engineers authoring and reviewing the code.
  - We use tools like clang- tidy (for C + +) and Error Prone (for Java) to automate the process of enforcing rules.
  - Most code at Google is subject to such a presubmit check. For our code, we use clang- format for C + +; an in- house wrapper around yapf for Python; gofmt for Go; dartfmt for Dart; and buildifier for our BUILD files.
1. Code Review
- Code Review Flow
  - Duplicated code not only is a wasted effort, it can actually cost more in time than not having the code at all; changes that could be easily performed under one code pattern often require more effort when there is duplication in the codebase.
- How Code Review Works at Google
  - Google’s codebase is a tree structure with hierarchical owners of particular directories. (See Chapter 16). Owners act as gatekeepers for their particular directories.
- Code Review Benefits
  - There is a recognition that strict processes tend not to work well for a dynamic company needing to respond quickly to new technologies, and that bureaucratic rules tend not to work well with creative professionals. Code review, however, is a mandate, one of the few blanket processes in which all software engineers at Google must participate.
- Code Review Benefits
  - code review processes that are heavyweight, or that don’t scale properly, become unsustainable.
  - A reviewer shouldn’t propose alternatives because of personal opinion. Reviewers can propose alternatives, but only if they improve comprehension (by being less complex, for example) or functionality (by being more efficient, for example). In general, engineers are encouraged to approve changes that improve the codebase rather than wait for consensus on a more “perfect” solution.
  - It is often useful to find a reviewer who has a different perspective from the author, especially a reviewer who might need, as part of their job, to maintain or use the code being proposed within the change.
    - 💭 — That Is a good idea
  - When an engineer marks a code review as LGTM, they are saying that the code does what it says and that it is understandable.
- Code Review Best Practices
  - Reviewers should be careful about jumping to conclusions based on a code author’s particular approach. It’s better to ask questions on why something was done the way it was before assuming that approach is wrong.
  - At Google, we expect feedback from a code review within 24 (working) hours. If a reviewer is unable to complete a review in that time, it’s good practice (and expected) to respond that they’ve at least seen the change and will get to the review as soon as possible.
  - Remember that you are not your code, and that this change you propose is not “yours” but the team’s. After you check that piece of code into the codebase, it is no longer yours in any case. Be receptive to questions on your approach, and be prepared to explain why you did things in certain ways.
  - Most changes at Google are expected to be reviewed within about a day. 7 (This doesn’t necessarily mean that the review is over within a day, but that initial feedback is provided within a day.)
  - Although the first line should be a summary of the entire change, the description should still go into detail on what is being changed and why.
  - The cost of additional reviewers quickly outweighs their value.
- Types of Code Reviews
  - To ensure that code is sustainable, a greenfield review should ensure that an API matches an agreed design (which may require reviewing a design document) and is tested fully, with all API endpoints having some form of unit test, and that those tests fail when the code’s assumptions change.
  - Inevitably, you will need to submit a change for a bug fix to your codebase. When doing so, avoid the temptation to address other issues. Not only does this risk increasing the size of the code review, it also makes it more difficult to perform regression testing or for others to roll back your change.
1. Documentation
- Types of Code Reviews
  - Engineers, therefore, need the proper tools and incentives to do so effectively. The key to making it easier for them to write quality documentation is to introduce processes and tools that scale with the organization and that tie into their existing workflow.
    - 💭 — +1 on that
- Why Is Documentation Needed?
  - Documentation is critical over time, and reaps tremendous benefits for especially critical code as an organization scales.
- Documentation Is Like Code
  - An engineer might write shell scripts or Python to run command- line tasks, or they might write most of their backend code in C + + but write some middleware code in Java, and so on. Each language is a tool in the toolbox.
  - Leveraging of existing developer workflows, rather than creating new ones, was a key benefit.
- Know Your Audience
  - A design document might need to persuade decision makers. A tutorial might need to provide very explicit instructions to someone utterly unfamiliar with your codebase. An API might need to provide complete and accurate reference information for any users of that API, be they experts or novices. Always try to identify a primary audience and write to that audience.
  - As Blaise Pascal once said, “If I had more time, I would have written you a shorter letter.”
- Documentation Types
  - Generally, a file comment should begin with an outline of what’s contained in the code you are reading.
  - Any API that cannot be succinctly described in the first paragraph or two is usually the sign of an API that is not well thought out. Consider breaking the API into separate components in those cases.
  - Function comments should stress the active nature of their use, beginning with an indicative verb describing what the function does and what is returned.
  - Combine all atomic user operations into single steps so that the user knows they need to do something at each step in the process.
- Documentation Philosophy
  - At Google, we often attach “freshness dates” to documentation. Such documents note the last time a document was reviewed, and metadata in the documentation set will send email reminders when the document hasn’t been touched in, for example, three months.
1. Testing Overview
- Why Do We Write Tests?
  - Keep in mind that tests derive their value from the trust engineers place in them. If testing becomes a productivity sink, constantly inducing toil and uncertainty, engineers will lose trust and begin to find workarounds. A bad test suite can be worse than no test suite at all.
  - we have built testing into the heart of our engineering culture.
  - To address these problems, the tech lead (TL) of GWS decided to institute a policy of engineer- driven, automated testing. As part of this policy, all new code changes were required to include tests, and those tests would be run continuously. Within a year of instituting this policy, the number of emergency pushes dropped by half. This drop occurred despite the fact that the project was seeing a record number of new changes every quarter. Even in the face of unprecedented growth and change,
  - After an engineer on the team writes a test, it is added to the pool of common resources available to others. Everyone else on the team can now run the test and will benefit when it detects an issue.
- Designing a Test Suite
  - the most important qualities we want from our test suite are speed and determinism,
  - You can’t run a server and have a separate test process connect to it. It also means that you can’t run a third- party program such as a database as part of your test.
  - The constraints placed on small tests can be too restrictive for many interesting kinds of tests.
  - We like to say that “a test should be obvious upon inspection.” Because there are no tests for the tests themselves, they require manual review as an important check on correctness.
- Testing at Google Scale
  - All changes are committed to the repository head
  - In addition to developing the proper culture, invest in your testing infrastructure by developing linters, documentation, or other assistance that makes it more difficult to write bad tests.
1. Unit Testing
- Preventing Brittle Tests
  - The takeaway is that after you write a test, you shouldn’t need to touch that test again as you refactor the system, fix bugs, or add new features.
  - If a method or class exists only to support one or two other classes (i.e., it is a “helper class”), it probably shouldn’t be considered its own unit, and its functionality should be tested through those classes instead of directly.
- Writing Clear Tests
  - A test is complete when its body contains all of the information a reader needs in order to understand how it arrives at its result.
  - particular, it can often be worth violating the DRY (Don’t Repeat Yourself) principle if it leads to clearer tests.
  - rather than writing a test for each method, write a test for each behavior.
  - The lesson is clear: in test code, stick to straight- line code over clever logic, and consider tolerating some duplication when it makes the test more descriptive and meaningful. We’ll discuss ideas around duplication and code sharing
1. Larger Testing
- Larger Tests at Google
  - One way to achieve this test ratio when presented with a user journey that can require contributions from many internal systems is to “chain” tests, as illustrated in Figure 14- 4, not specifically in their execution, but to create multiple smaller pairwise integration tests that represent the overall scenario. This is done by ensuring that the output of one test is used as the input to another test by persisting this output to a data repository.
- Structure of a Large Test
  - if the backend provides a public API, it is often easier to split the tests into connected tests at the UI/ API boundary and to use the public API to drive the end- to- end tests. This is true whether the UI is a browser, command- line interface (CLI), desktop app, or mobile app.
- Types of Larger Tests
  - Many times, it is not the code that is the source of defects but instead configuration: data files, databases, option definitions, and so on.
  - Any defects found by exploratory tests should be replicated with an automated test that can run much more frequently.
  - One common approach we use for manual exploratory testing is the bug bash. A team of engineers and related personnel (managers, product managers, test engineers, anyone with familiarity with the product) schedules a “meeting,” but at this session, everyone involved manually tests the product.
    - 💭 — That's An interesting idea
  - modes for a given publicly facing product. Additionally, as Hyrum’s Law states, the actual public API is not the declared one but all user- visible aspects of a product.
  - Maps. A/ B diff tests operate by sending traffic to a public API and comparing the responses between old and new versions (especially during migrations). Any deviations in behavior must be reconciled as either anticipated or unanticipated (regressions).
  - Even though software is a digital asset and the physical bits themselves don’t degrade, new technologies, libraries, techniques, languages, and other environmental changes over time render existing systems obsolete.
  - For long- running software ecosystems, planning for and executing deprecation correctly reduces resource costs and improves velocity by removing the redundancy and complexity that builds up in a system over time.
1. Deprecation
- Why Deprecate?
  - code is a liability, not an asset. After all, if code were an asset, why should we even bother spending time trying to turn down and remove obsolete systems?
  - Code itself doesn’t bring value: it is the functionality that it provides that brings value. That functionality is an asset if it meets a user need: the code that implements this functionality is simply a means to that end.
- Why Is Deprecation So Hard?
  - staffing a team and spending time removing obsolete systems costs real money, whereas the costs of doing nothing and letting the system lumber along unattended are not readily observable.
  - don’t start projects that your organization isn’t committed to support for the expected lifespan of the organization.
- Types of Deprecation
  - we hope that clients move, but can’t force them to. As our friends in SRE will readily tell you: “Hope is not a strategy.”
  - we strongly advocate that compulsory deprecations are actively staffed by a specialized team through completion.
  - when a system is slated for deprecation and removal, the team will announce planned outages of increasing duration in the months and weeks prior to the turndown.
  - In particular, we find “trunk- based development” as popularized by DevOps1 (one repository, no dev branches) to be a particularly scalable policy approach, and we’ll provide some suggestions as to why that is.
1. Version Control and Branch Management
- Version Control at Google
  - For an individual developer, lack of choice can seem like an arbitrary impediment. Yet we see again and again that for an organization, it’s a critical component in efficient scaling.
1. Build Systems and Build Philosophy
- What Happens Without a Build System?
  - For a single developer working on at most a couple hundred lines of code for at most a week or two (which might have been the entire experience thus far of a junior developer who just graduated university), a compiler is all you need. Scripts can maybe take you a little bit farther. But as soon as you need to coordinate across multiple developers and their machines, even a perfect build script isn’t enough because it becomes very difficult to account for the minor differences in those machines. At this point, this simple approach breaks down and it’s time to invest in a real build system.
- Modern Build Systems
  - Fundamentally, they aren’t that different from the aforementioned script- based DIY approach we were working on: they run the same compilers under the hood, and you need to understand those underlying tools to be able to know what the build system is really doing.
    - 💭 — Cargo?
  - The fundamental problem is that we want the build system to be aware of these files without having to check them into source control. Updating a dependency should be a conscious choice, but that choice should be made once in a central place rather than managed by individual engineers or automatically by the system.
  - for there to be any benefit from a remote cache, downloading an artifact needs to be faster than building it. This is not always the case, especially if the cache server is far from the machine doing the build. Google’s network and build system is carefully tuned to be able to quickly share build results.
    - 💭 — That may be one of the reasons why remote work would be so hard for them. It breaks many given assumptions.
  - Changes to a project’s build system can be expensive, and that cost increases as the project becomes larger. This is why Google believes that almost every new project benefits from incorporating an artifact- based build system like Bazel right from the start. Within Google, essentially all code from tiny experimental projects up to Google Search is built using Blaze.
1. Critique: Google’s Code Review Tool
- Code Review Tooling Principles
  - Code review is not for slowing others down; instead, it is for empowering others.
  - Trust and communication are core to the code review process. A tool can enhance the experience, but it can’t replace them.
- Stage 1: Create a Change
  - For example, suppose that a linter finds a style violation of extra spaces at the end of the line. The change page will display a chip for that linter. From the chip, the author can quickly go to the diff showing the offending code to understand the style violation with two clicks. Most linter violations also include fix suggestions. With a click, the author can preview the fix suggestion (for example, remove the extra spaces), and with another click, apply the fix on the change.
    - 💭 — That's Great
1. Static Analysis
- Characteristics of Effective Static Analysis
  - Fixing a static analysis warning could introduce a bug. For code that is not being frequently modified, why “fix” code that is running fine in production?
  - we generally focus on newly introduced warnings; existing issues in otherwise working code are typically only worth highlighting (and fixing) if they are particularly important (security issues, significant bug fixes, etc.).
- Tricorder: Google’s Static Analysis Platform
  - antipatterns could represent real bugs. For example, consider the following code snippet hashing a field f of type long: result = 31 * result + (int) (f ^ (f > > > 32)); Now consider the case in which the type of f is int. The code will still compile, but the right shift by 32 is a no- op so that f is XORed with itself and no longer affects the value produced. We fixed 31 occurrences of this bug in Google’s codebase while enabling the check as a compiler error in Error Prone.
    - 💭 — These are the real useful checks we're expecting from the static analysis.
  - we display the option to click a “Not useful” button on an analysis result; this click provides the option to file a bug directly against the analyzer writer about why the result is not useful with information about analysis result prepopulated. Code reviewers can also ask change authors to address analysis results by clicking a “Please fix” button.
    - 💭 — That's indeed very useful. I will consider proposing that as a manual process (as we don't need an entire Google system right now)
  - Although not every language at Google has this policy, the most frequently used ones do. Both of the Java and C + + compilers have been configured to avoid displaying compiler warnings. The Go compiler takes this to extreme; some things that other languages would consider warnings (such as unused variables or package imports) are errors in Go.
    - 💭 — OMG, that's why we have such a ridiculous policy in Go... 🤦‍♂️
1. Dependency Management
- Importing Dependencies
  - Internally, we already have roughly 250 million lines of C + + code that depend on this library
    - 💭 — 😱
  - it is important to realize that dependency management has a wholly different nature in a programming task versus a software engineering task. If you’re in a problem space for which maintenance over time is relevant, dependency management is difficult. If you’re purely developing a solution for today with no need to ever update anything, it is perfectly reasonable to grab as many readily available dependencies as you like with no thought of how to use them responsibly or plan for upgrades.
- Dependency Management, In Theory
  - Live at Head presupposes that we can unpin dependencies, drop SemVer, and rely on dependency providers to test changes against the entire ecosystem before committing.
  - The incentive structures and technological assumptions here are materially different than other scenarios: we assume that there exist unit tests and CI, we assume that API providers will be bound by whether downstream dependencies will be broken, and we assume that API consumers are keeping their tests passing and relying on their dependency in supported ways.
- The Limitations of SemVer
  - you can’t prove anything about compatibility when only considering the source API; you have to know with which things you are asking about compatibility.
  - The compression inherent in “I made a breaking change; I must bump the major version number” is lossy when it doesn’t apply at the granularity of an individual atomic API unit.
  - There is a further argument that SemVer doesn’t always incentivize the creation of stable code.
    - 💭 — Well... It's the trade off of the decentralization 🤷‍♂️
  - Repackaging and renaming everything seems like a reasonable amount of work to expect from a provider in exchange for them taking the nuclear option and throwing away backward compatibility.
    - 💭 — That's a good point. Not sure if all breaking changes are nuclear options though.
  - However, our experience at Google suggests that it is unlikely that you can have any of those three properties at scale and keep them working constantly over time.
    - 💭 — At Google's scale, not any medium sized project.
- Dependency Management with Infinite Resources
  - As the Apache community saying goes, we ought to prioritize “community over code.”
  - “Don’t release things without a plan (and a mandate) to support it for the long term.”
1. Large-Scale Changes
- Who Deals with LSCs?
  - Centralizing the migration and accounting for its costs is almost always faster and cheaper than depending on individual teams to organically migrate.
  - Although fixing this single- character change might seem pointless, particularly across a codebase the size of Google’s, the maturity of our LSC tooling and process enabled us to do it with just a couple weeks’ worth of background- task effort.
    - 💭 — Just a couple of weeks :grimacing:
- Barriers to Atomic Changes
  - it might not be just “difficult” or “unwise” to make a large change atomically: it might simply be impossible with a given set of infrastructures.
  - The SREs who run Google’s production services have a mantra: “No Haunted Graveyards.” A haunted graveyard in this sense is a system that is so ancient, obtuse, or complex that no one dares enter it.
  - Google’s codebase had more than 500,000 references to scoped_ptr scattered among millions of source files.
- LSC Infrastructure
  - Google’s use of the semantic indexing tool Kythe provides a complete map of the links between parts of our codebase, allowing us to ask questions such as “Where are the callers of this function?” or “Which classes derive from this one?”
    - 💭 — That may be very useful
  - languages that tend to be viewed as more focused on developer productivity tend to be more difficult to maintain.
- The LSC Process
  - If a particular owner proves to be unresponsive, Rosie adds additional reviewers automatically in an effort to get a change reviewed in a timely manner.
1. Continuous Integration
- CI Concepts
  - why not just run all tests on presubmit? The main reason is that it’s too expensive. Engineer productivity is extremely valuable, and waiting a long time to run every test during code submission can be severely disruptive.
  - CI Is Alerting Titus Winters As with responsibly running production systems, sustainably maintaining software systems also requires continual automated monitoring. Just as we use a monitoring and alerting system to understand how production systems respond to change, CI reveals how our software is responding to changes in its environment.
  - Policies that say, “Nobody can commit if our latest CI results aren’t green” are probably misguided. If CI reports an issue, such failures should definitely be investigated before letting people commit or compound the issue. But if the root cause is well understood and clearly would not affect production, blocking commits is unreasonable.
    - 💭 — That said, having a non-green status and dismiss is quite problematic for the trust in the alert
- CI at Google
  - Every day it is responsible for handling more than 50,000 unique changes and running more than four billion individual test cases.
  - To deal with such breakages, each team has a “Build Cop.” The Build Cop’s responsibility is keeping all the tests passing in their particular project, regardless of who breaks them. When a Build Cop is notified of a failing test in their project, they drop whatever they are doing and fix the build.
  - The presence of failing tests can quickly begin to erode confidence in the test suite. As mentioned previously, fixing a broken build is the responsibility of the Build Cop. The most effective tool the Build Cop has is the rollback.
  - Before long, Takeout faced “flag issues.” Flags added for one of the instances would break the others, and their deployments would break when servers could not start up due to configuration incompatibilities.
  - The team came up with a strategic way to disable failing tests by tagging them with an associated bug and filing that off to the responsible team
    - 💭 — Linking skipped tests to bugs is actually quite clever. I see this working even in simple codebases. It's weird to have a test skipped without a reason written down
  - The value of code is not realized at the time of submission but when features are available to your users.
1. Continuous Delivery
- Velocity Is a Team Sport: How to Break Up a Deployment into Manageable Pieces
  - If your releases are costly and sometimes risky, the instinct is to slow down your release cadence and increase your stability period.
  - In some cases, at Google, the answer has been to rewrite an application from scratch rather than simply migrating it, establishing the desired modularity into the new architecture. Although either of these options can take months and is likely painful in the short term, the value gained in terms of operational cost and cognitive simplicity will pay off over an application’s lifespan of years.
- Evaluating Changes in Isolation: Flag-Guarding Features
  - Turning on a flag for 100% of your users all at once is not a great idea, so a configuration service that manages safe configuration rollouts is a good investment.
- Striving for Agility: Setting Up a Release Train
  - A world of regular releases means that if a developer misses the release train, they’ll be able to catch the next train in a matter of hours rather than days. This limits developer panic and greatly improves work– life balance for release engineers.
    - 💭 — If it's just hours, it would be quite acceptable indeed
- Shifting Left: Making Data-Driven Decisions Earlier
  - One of our release managers shared a piece of wisdom that turned the situation around when he said that the diversity of our client market was not a problem, but a fact.
- Conclusion
  - we’ve found that, counterintuitively, faster is safer.
  - faster is cheaper, because having a predictable, frequent release train forces you to drive down the cost of each release and makes the cost of any abandoned release very low.
  - I don’t try to understand computers. I try to understand the programs. Barbara Liskov
1. Compute as a Service
- Taming the Compute Environment
  - However, the growth of the number of datacenters Google manages meant that we moved toward a model in which turning up a datacenter is an automated process that does not require human intervention.
- Writing Software for Managed Compute
  - If your server is a pet, when it’s broken, a human comes to look at it (usually in a panic), understand what went wrong, and hopefully nurse it back to health. It’s difficult to replace. If your servers are cattle, you name them replica001 to replica100, and if one fails, automation will remove it and provision a new one in its place.
- CaaS Over Time and Scale
  - This underlines the challenges of designing a container system that will prove maintainable over time and thus the value of using a container system developed and used by a broader community, where these types of issues have already occurred for others and the lessons learned have been incorporated.
    - 💭 — Community ❤️
- Choosing a Compute Service
  - code will be written in a way that takes advantage of all the properties of the system (Hyrum’s Law); thus, for instance, if you choose a VM-based offering, teams will tweak their particular VM images; and if you choose a specific container-based solution, teams will call out to the APIs of the cluster manager.
  - Some teams were creative in their desire to limit memory usage and replaced (in their custom filesystem overlay) the Bash command with a custom-written piece of “execute the second argument” code. These teams, of course, were very aware of their memory usage, and so when the Borg team changed the process runner to use ash (which was not overwritten by the custom code), their memory usage increased (because it started including ash usage instead of the custom code usage), and this caused alerts, rolling back the change, and a certain amount of unhappiness.
    - 💭 — Fixing workarounds actually generated more problems. LOL
  - It’s worth mentioning that many or most serverless frameworks are built on top of other compute layers: AppEngine runs on Borg, Knative runs on Kubernetes, Lambda runs on Amazon EC2.
  - The other is to run multicloud; that is, to use managed services based on the same open source solutions from two or more different cloud providers (say, GKE and AKS for Kubernetes). This provides an even easier path for migration out of one of them, and also makes it more difficult to depend on specific implementation details available in one one of them.
    - 💭 — I have some major concerns about being tied to a specific provider
  - Along the way, he has started several Google projects that are believed to be in the top-10 largest refactorings in human history.

Review of Polished Ruby Programming

Unknown — Tue, 17 Aug 2021 00:00:00 +0000

Book: Polished Ruby Programming: Build better software with more intuitive, maintainable, scalable, and high-performance Ruby code by Jeremy Evans. Rating: ⭐️⭐️⭐️⭐️.

I got a contact from Packtpub about this book. The deal was to receive the book for free in exchange for an honest review. Here I am, just finished the book and will write about it.

The book is quite good, there's a lot of good information there, and I would totally recommend to someone investing in Ruby.

The author did some great contributions to the Ruby community (Ruby Committer, Lead developer of Sequel, Roda, and Rodauth. OpenBSD ruby ports maintainer.), is doing software and community work for many years now (I can quickly check his open source work since 2008), and has some strong opinions about famous Ruby libraries.

For most of the book, I was totally into the narrative and how the author was organizing information. When things started to go more into the web, I started to feel something different. It felt like the author was selling one library or the other, because they were much better than others. Turns out, it's the libraries he created himself 🙄. After that, I had the same feeling, until I finished the book.

The book still deserves a 4 star review. The content until the web part is indeed great. Jeremy was able to write down some interesting pieces of advice on how to use Ruby in some particular scenarios where performance is needed. I especially liked the chapter 6, about code formatting. The final part of the book is also OK, but you have to read it with a grain of salt as it feels like a mother talking about how pretty is her son/daughter. 😅

Here are my kindle highlights and my comments (in 💭) about the book:

Chapter 1: Getting the Most out of Core Classes

Ruby's core classes also use nil as a signal that a method that modifies the receiver did not make a modification:
When you want to cache an expression that may return nil or false as a valid value, you need to use a different implementation approach.
- 💭 — Context : memoization
One advantage of using true, false, and nil compared to most other objects in Ruby is that they are three of the immediate object types. Immediate objects in Ruby are objects that do not require memory allocation to create and memory indirection to access, and as such they are generally faster than non-immediate objects.
Any time you are considering using division in your code and both arguments could be integers, be aware of this issue and consider whether you would like to use integer division. If not, you should convert the numerator or denominator to a different numeric type
do not avoid the use of rationals on a performance basis unless you have profiled them and determined they are a bottleneck
Ruby is focused on programmer happiness and productivity, so it will often automatically convert a string to a symbol if it needs a symbol, or a symbol to a string if it needs a string.
While it looks like symbols and strings are as interchangeable as the method argument to send, this is only because Ruby tries to be friendly to the programmer and accept either.
Module# define_method, Kernel# instance_variable_get, and Module# const_get. The general principle when using these methods in Ruby code is always to pass symbols to them, since it results in better performance.
if you need to accept a configuration value that can only be one of three options, it's probably best to use a symbol:
Array#& uses a linear search of the array, so this approach is very slow for a large number of artists.
Set is actually implemented using a hash internally,
- 💭 — That's Interesting
you should only use a set for code that isn't performance-sensitive and you would like to use a nicer API. For any performance-sensitive code, you should prefer using a hash directly.
a Struct class is a little lighter on memory than a regular class, but has slower accessor methods.
freezing the receiver in initialize is the best approach.
- 💭 — To get an immutable struct

Chapter 2: Designing Useful Custom Classes

As a general principle, you should delay increasing complexity in your class designs until you actually need the complexity.
- 💭 — YES !
While the Liskov substitution principle is useful to follow in general, you should not be dogmatic about applying it. In a strict sense, all subtypes that have different behavior than their supertypes or produce different results could be said to violate Liskov substitutability,
Ruby, in general, respects that the programmer will know to do the right thing.
- 💭 — It's Both a blessing and a curse
There is one method in Ruby that will almost always break Liskov substitutability, and that you should generally avoid, and that is instance_of?.
These approaches should almost always use kind_of? instead,
- 💭 — Instead Of instance of
The problem with this approach is that it prevents you from using multithreaded tests to speed up your testing.
- 💭 — Overwriting Date.today
Unless your code has already been tightly optimized, there are probably better ways to optimize your application than attempting to use a custom data structure instead of a Ruby array or hash.

Chapter 3: Proper Variable Usage

if you are writing a general-purpose library, you should not modify core classes unless that is the purpose of the library.
array_class = Array
- 💭 — Performance Sensitive
the length of the variable name should be roughly proportional to the inverse of the size of the scope of the variable,
You could also use a numbered parameter in this case: @albums.each do puts _1. name end
- 💭 — That's new to me
Note that it is possible to be more explicit and use instance_variable_defined?(:@ total_tax) instead of defined?(@ total_tax), but it is recommended that you use defined? because Ruby is better able to optimize it. This is because defined? is a keyword and instance_variable_defined? is a regular method, and the Ruby virtual machine optimizes the defined? keyword into a direct instance variable check.
The scope of instance variables is always the same as the implicit receiver of methods, self.
accessing local variables is faster than accessing instance variables.
Ruby's constant lookup algorithm: Look in the current namespace (W in the previous example). Look in the lexical namespaces containing the current namespace (X, Y, and Z in the previous example). Look in the ancestors of the current namespace, in order (U in the previous example). Do not look in ancestors of the lexical namespaces containing the current namespace.
You can make constants not externally accessible using private_constant:
Class variable semantics are bad enough that the Ruby core team now recommends against their use, and no longer considers it worth it to even fix bugs in how class variables are handled.
Using a mutable constant to work around constant reassignment warnings is definitely a hack and not an implementation recommendation. It's a bad idea to use this approach, for the same reason it is bad to rely on globally mutable data structures in general.
The main issues with using global variables in Ruby are the same as using global variables in any programming language, in that it encourages poor coding style and hard-to-follow code.

Chapter 4: Methods and Their Arguments

When using the frozen-string-literal magic comment to make all the strings in a file frozen, even dup, a three-letter method name, was considered too long, so they added the +@ unary operator on strings (+@ doesn't duplicate the string if it isn't frozen, but it is almost always used on frozen strings).
- 💭 — How Is that a good name!?
For methods that should only be called once during application initialization for configuring applications, it's a good idea to give them very descriptive names.
If you are considering writing a method with many required arguments, strongly consider the argument ordering issues involved before doing so.
If you want to avoid array allocation in all cases, you can use a frozen constant, as follows: EMPTY_ARRAY = []. freeze def a( bar = EMPTY_ARRAY) end
You can mimic this API in Ruby by using a rest argument for additional sources and a post argument for the destination: def mv( source, *sources, dir)
OPTIONS = {}. freeze def foo( options = OPTIONS) end With this approach, calling the method without options never allocates a hash.
in Ruby 3, calling a method with a # keyword splat does not allocate a hash
it is best to use keyword arguments instead of an optional positional hash argument.
If you are maintaining Ruby code that uses positional arguments with default hash values as a replacement for keyword arguments, you should consider whether you want to convert them into keyword arguments.
it is never safe to modify the arity of what you are yielding to a block if users can pass a lambda proc as the block argument.
any time you break backward compatibility in a library, even in a major version, you should have a good reason to. Even if their code breaks, the users of a library tend to feel less betrayed and annoyed when they can see that such a breakage was necessary for greater progress.
What about the visibility of constants? In general, it's best to use private_constant for any constant you do not want to expose to users. Only leave a constant public if there is a good reason for it to be public.
Once a constant is public, it's part of your library's interface, and you should treat changes that are made to the constant similar to changes that are made to any public method, so do your best to keep backward compatibility for it.
If you have a lot of methods and constants that are currently public and should be made private, it is a little tedious to do all this method_missing and const_missing overriding. In that case, you can use the deprecate_public gem to handle all the hard work for you:
Delegating all arguments to another method is such a common pattern in Ruby that they added a shortcut for it in Ruby 2.7 by using ...:

Chapter 5: Handling Errors

Both Python and Ruby support similar behavior for retrieving data from hashes, but Ruby, in this case, is permissive, while Python, in this case, is strict.
Ruby's permissiveness in either area can be considered a bug or a feature, depending on your point of view. Most programmers who prefer to use Ruby probably consider it a feature, since otherwise, they would probably prefer to use another language.
This is the principle of misuse resistance. A method that does not raise an exception for errors is easier to misuse than a method that raises an exception for errors.
code uses exceptions for flow control, which is, in general, a bad approach.
One consideration when using exceptions is that they get slower in proportion to the size of the call stack. If you have a call stack with 100 frames, which is quite common in Ruby web applications, raising an exception is much slower than if you only have a call stack with 10 frames.
You can include a third argument to raise, which is the array to use for the backtrace. If you want to make the exception handling as fast as possible, you can use an empty array: raise ArgumentError, "message", []
raise ArgumentError, "message", EMPTY_ARRAY
Because the exception being raised has no backtrace, it is much more difficult to debug if you run into problems.
if you have a module named LibraryModule and want to add support for backtraceless exceptions, you could add a skip_exception_backtraces accessor, as shown in this example: exception = ArgumentError.new(" message") if LibraryModule.skip_exception_backtraces exception.set_backtrace( EMPTY_ARRAY) end
the retry keyword is only valid inside rescue clauses, it is not valid in the begin clause. That's a bummer.
The redo keyword is one of the least used keywords in Ruby. If you haven't used it before, it is similar to the next keyword, but instead of going to the next block iteration, it restarts the current block iteration.
In general, procs and lambdas (Proc instances) are among the more expensive object instances to create, at least compared to other core classes.
The following code is a modified implementation of a classic exponential backoff algorithm: sleep( 3 * (0.5 + rand/ 2) * 1.5**( retries-1))
It's important that Foo:: Error is a subclass of StandardError and not of Exception. You should only subclass Exception in very rare cases because subclasses of Exception are not caught by rescue clauses without arguments.
In general, idiomatic Ruby code avoids defensive programming based on types, because in Ruby, what matters is what methods the object responds to and the objects returned by those methods.

Chapter 6: Formatting Code for Easy Reading

it is often a good idea to enforce syntactic consistency. Enforcing syntactic consistency can increase the performance of philosophers. The poets may find such code boring and not as fun to work on, and it is likely that enforcing syntactic consistency will affect their enjoyment of working on the code, but it is unlikely that enforcing syntactic consistency will harm their productivity, as they are, in general, able to read and write a wide variety of styles.
What is important is to know where in general, on the poet-philosopher spectrum, the programming team maintaining the code lies, so you can choose whether or not to enforce syntactic consistency in the library.
RuboCop has a solution for this, which is the configuration parameter, AllCops:DisabledByDefault. Using this configuration parameter, you can only enable the syntax checks that you believe will be helpful for your library.
The argument against arbitrary limits is simple: if there was a better approach that was within the limit, it would have already been used. The argument for arbitrary limits is also simple: the programmer is too stupid, ignorant, or inexperienced to know what the best approach is, and an arbitrary limit can reduce the possible damage, by forcing the programmer to restructure their code. A simple counterargument to that is if the programmer is too stupid, ignorant, or inexperienced to do things correctly within the limit, why do we trust them to split the code intelligently into smaller parts to get around the limit?
In short, don't assume that RuboCop knows better than you do and keep the default arbitrary limits. Use your judgment on what API makes sense for your library.
- 💭 — OMG. This whole chapter is ✨

Chapter 8: Designing for Extensibility

A library based on a plugin system, even if the library itself is quite large, will generally have a small enough core that a new user can read through the core of the library within a few hours and have a good idea about how it works.
libraries designed around plugin systems tend to be significantly faster. The startup time for libraries that only load the core of the library by default is often significantly faster than startup times for monolithic libraries.

Chapter 9: Metaprogramming and When to Use It

The main difference between programming and metaprogramming in Ruby is conceptual.
It would definitely suck to have to define accessor methods this verbosely. It's hard to believe, but there are programming languages where you still have to do that, even some that were originally released after Ruby.
- 💭 — Haha
If this is the only place you are using methods like this in your library or application, it's best to metaprogram directly in the class to avoid unnecessary indirection and keep the definitions local to the class
singleton_class.extend HashAccessor
extend is shorthand for singleton_class.include,
Ruby will support as many levels of singleton classes as you need for your metaprogramming.
let's say you are working on a module named Rusty, for writing rusty code. Rusty code strives to be one-third more efficient than Ruby code by defining methods using only two characters, fn, instead of the normal three you need in Ruby (def).
- 💭 — I got that reference 🦀
if you are doing metaprogramming in Ruby, the block-based approach is the approach you want to reach for first. However, there is another approach, a dangerous approach, called the eval-based approach. With the eval-based approach, instead of metaprogramming with Ruby objects, you metaprogram by building a string of Ruby code.
In addition to much clunkier code, the eval-based approach is far less safe. Because eval evaluates arbitrary Ruby code, it can do things such as delete every file you have access to.
- 💭 — It make me remember of a eval(params) I once saw
if you absolutely must have the fastest possible performance and need to deal with untrusted data, you can use a whitelisting approach.
Baz.class_eval "def #{ name}; :foo end" That's because the value of the name variable could be "x; end; File.delete(__FILE__); def y; ", as some users might just think it is funny to delete the file running the code.
However, another approach is to create a subclass of BasicObject and override method_missing in it, then instance_exec the block in the context of an instance of that BasicObject subclass. This is shown in the following code block: def words(& block) array = [] Class.new( BasicObject) do define_method(: method_missing) do | meth, *| array < < meth end end.new.instance_exec(& block) array.reverse end
Defining actual methods is much better for performance. In addition, with actual methods, calling Struct50. instance_methods returns all of the methods, which is much better when you need to figure out which methods instances of the class respond to.
- Dont use method missing unless it's really needed
While it's almost always better to use define_method over method_missing when you know the valid methods upfront, there is a case where you still want to use method_missing. That is when you have a very large number of valid methods, say over 1,000. The reason to prefer method_missing, in that case, is that each method defined with define_method has a cost in terms of memory used, with a related performance cost for the garbage collector. With method_missing, there are no separate methods, so there is no memory or garbage collector cost.

Chapter 10: Designing Useful Domain-Specific Languages

In this section, you learned about DSLs for configuring a library, using a real-world example from RSpec.
- Great examples and explanation
After programmer friendliness, probably the main reason you see so many DSLs in Ruby is the simplicity of implementation.
- 💭 — Which is good but also bad IMO
The best cases for DSL use in Ruby are where using the DSL makes the library easier to maintain and makes it simpler for a user to use the library.
implementing a DSL just to reduce code verbosity is often a bad idea. Try hard to think of alternative approaches to using a DSL if you are using it just to reduce code verbosity.

Chapter 11: Testing to Ensure Your Code Works

Testing is more critical in Ruby than in most other programming environments, partly because of the power and flexibility Ruby offers, and also because of Ruby's dynamic typing.
Ruby programs are also generally not compiled until you try to run them, so even simple syntax errors will not be caught unless you try to load the related code. Combined, these two qualities make testing in Ruby more critical than in many other programming languages.
Ruby does ship with the ability to just compile programs and not actually run them, it's just not commonly used. This feature is very useful with large libraries if you just want to check that there are no syntax errors in any of the source files. You can access this feature using the -c command-line option, such as ruby -c file_name.
Scanning all files with ruby -wc is a great idea, but it only does some fairly basic checks on the file.
either because they are too difficult or the tests or specifications have bugs and it is actually impossible to have correct answers returned due to missing input.
The main issue with TAD is you can end up implementing a feature that works, but the interface to use it is hard to use or testing it is difficult. If you use a TAD approach, you need to realize this while you are writing the feature, and constantly remind yourself to think of how the user will use the feature, make sure to keep that usage as simple as you can and avoid unnecessary complexity.
TAD approach focused on implementing a design, and not simply on passing a test. Just as you need to focus on the user experience and not just use the easiest implementation approach with TAD, you need to focus on the user experience and not just use the easiest testing approach with TDD.
If non-programmers will not be assisting the programming team by writing specifications, BDD generally ends up being mostly wasted effort.
tests are designed to help avoid and debug problems in library code. The more abstractions you use in your test code, the more likely you are to be debugging your test code instead of your library code.
Once you reach a certain level of test abstraction, a failing test gives you no confidence about whether the bug is in the library or the tests themselves, and that is a bad situation to be in.
avoid abstracting the parts of the specs that are performing the actual testing, as opposed to setting up for the actual testing.
Slow and reliable tests are in general much better than fast tests that break without reason (false positives) and don't catch actual breakage (false negatives).
Realizing that 100% coverage means nothing
This brings us to the critical concept in regards to code coverage, which is that 100% coverage means nothing. The corollary to this concept is even more important, and that is that less than 100% coverage means something. Having 100% code coverage does not tell you anything, but having less than 100% code coverage tells you something. At the very least, having less than 100% code coverage means that there are certain parts of your code that you are not testing at all.

Chapter 12: Handling Change

Removing features sounds like a bad thing for most new programmers, but it is probably one of the happiest moments for experienced programmers.
Things become more complicated if you still need to call the method internally until it is removed. In this case, it's best to have an internal private alias to the method that doesn't raise a warning, and change all internal callers to use it:
If the feature being removed is a constant and not a method, you can use deprecate_constant:
in Ruby 3, deprecation warnings are not shown by default, even when we have $ VERBOSE = true. You need to use the -w flag when starting Ruby,

Chapter 13: Using Common Design Patterns

While design patterns are not as necessary in Ruby as they are in less powerful languages, they are still a useful tool to have in your toolbox.
The null object pattern should only be used if you can always or almost always treat the null object as a real object.
In general, it is best to avoid the null object pattern in performance-sensitive code, even if it would otherwise be a good fit.
With the adapter pattern, you write an adapter with the interface you want to use that wraps the objects that use a different interface.
The strategy pattern is almost the same as the adapter pattern, except that you don't wrap another object. Instead, you provide different implementations, or strategies, for performing the same operation.

Chapter 14: Optimizing Your Library

no language that is as dynamic, easy to use, and programmer-friendly as Ruby is as fast as Ruby.
If you are using Ruby, it is likely in an environment where the flexibility and ease of use of Ruby outweigh the potential performance issues.
There are a couple of good options for profiling libraries in Ruby, ruby-prof and stackprof. There are other profilers for Ruby, such as rack-mini-profiler and rbspy, but they mostly focus on profiling production applications and not libraries,
No code is faster than no code.
- 💭 — ???. This sentence was quite confusing to me.
With the important realization that the methods are idempotent, you could reoptimize the approach where you were optimizing for performance by caching results:
- That's one of the arguments that make funcional Programming faster
The most important aspect of a benchmark is how well the benchmark reflects how the library is actually used. When possible, try to create benchmarks that are actual production use cases or similar to production use cases.
If you find any code that can be moved from the initialize method to a separate method, moving the code to the separate method will improve performance in most cases.
the [] method is better optimized internally by Ruby's virtual machine, for array and hash.
- 💭 — ore than .first and .last, but that's a micro optimization
If you are going to use these types of micro-optimizations, recheck that they are still faster with each new Ruby release.

Chapter 15: The Database Is Key

The database is where all of an application's data is stored, and in most cases, an application's data is more important than the application itself.
An application written in Ruby using intelligent database design and indexing will often outperform an application written in C with less intelligent database design and improper indexing.
If you value your data at all and your database has any structure at all, a schemaless document database is usually a poor choice that you will end up regretting later when you discover anomalies in your data, far too late to fix them. Most key-value databases are too limited for the use of structured data unless they are treated as document databases, in which case they have the same issues as document databases. Unless you have studied and have had experience with graph databases and are sure they are the best database type for your application, they probably aren't. Similarly, unless you have very specialized needs, a specialized database such as a time series database is probably the wrong choice for your application.
- 💭 — That's a great definition of how to choose a database
PostgreSQL is the most robust open source database and has greater support for advanced data types and indexes. It is possible to be successful with MySQL, but you need to be careful to configure MySQL in a way that will not result in silent data loss.
If you must use SQLite, make sure to use CHECK constraints as much as possible to actually enforce database types.
Denormalizing your database should only be done as a form of performance optimization.
When profiling and benchmarking, try to use a copy of the production database, because database performance is often dependent on what data is being stored in the database.
Remember that denormalizing is always a tradeoff to get increased performance in particular cases while making other cases more difficult.
Do not blindly add created_at and updated_at columns to every table, only add them to the tables that really need both. By limiting the size of your database tables, you'll make access to those tables faster. Remember that you can always add columns later if you determine you really need the information.
- 💭 — Not sure if I agree. There were times I missed having a created or updated at and they were not there. Remember you can also always delete data 🤷‍♂️
If you are going to be accessing tracks by release date, but then showing them in order by name, you'll want a composite index on the release_date column and the name column in that order, because that will allow the database to avoid a separate sort step when retrieving the data.
When adding an index on a single column, always consider whether it is a better idea to add a composite index with that column as the first column and an additional column added after. Such composite indexes are in general more flexible and can optimize more types of queries, though they may not optimize a specific query as well.
You should avoid any feature that does not allow the enforcement of referential integrity, such as polymorphic associations. There are only rare exceptions where referential integrity shouldn't be enforced with foreign keys, such as audit logs stored in the database where you need to allow the deletion of rows but still retain the audit logs.
If it is possible, it is much faster to write a database function for performing the same operation, and issue a single UPDATE statement to update all rows at once. This is usually at least one order of magnitude faster, and sometimes multiple orders of magnitude faster.
- 💭 — Yes, but faster is not the only thing to consider whin developing software. Wnat about versioning? Discoverability? Maintenance? Tests? etc.
Do the concatenation in the database via a query such as this: # SELECT first_name | | ' ' | | last_name FROM names; The preceding command is going to be significantly faster than a query such as this: # SELECT first_name, last_name FROM names
- 💭 — Yes, but it always depends on the app. Is the database the bottleneck?
if you have a table of employees, and you want to enforce that the username column for the employee is unique, but only for active employees, you cannot just add a unique index on the username column. This is because if a previous employee had that user name 10 years ago, a new employee wouldn't be able to use it. For this case, use a partial unique index, where you enforce uniqueness on username, but only when the active column is true.
constraints as the primary method of enforcing data consistency, with model validations only being used to provide nicer error messages. The advantage of Sequel's approach is that if you modify the database without going through the model layer, data consistency issues will still be caught by the database.

Chapter 17: Robust Web Application Security

You should never try to forbid what is known to be bad (the blacklist approach to security). Instead, you should only allow what you know to be good (the whitelist approach).

Fixing Logitech mouse MX Master 2 problem

Unknown — Tue, 22 Jun 2021 00:00:00 +0000

This is a quick post for any Logitech MX master 2 (any version, really) owner having problems with their mouse. If your mouse is not moving at all but buttons are still working, there's a good chance your problem has an easy fix.

There's a video (in pt-BR) about that if you prefer doing it more interactively, but in summary: The [hidden] thumb button is the problem. It gets stuck and messes up everything. I never used that button, and it's just there, ruining everything. If you're using it... well... I suggest not using anymore. 🤷

To fix that, you will need a small Philips and a Torx T4 screwdriver. I got mine by buying a cheap (~7 USD) iPhone repair toolkit.

To open your mouse you will need your Torx T4 screwdriver to remove the top 2 screws, and then you will have to remove the rubber protection from both sides to have access to the other 4 philips screws there. Be sure to do it carefully, so you can put it back later.

Open your mouse and disconnect the cable between the two parts. In my case, removed the cable lock (I have no idea what's the real name for that) by mistake, but you can just pull it up:

The piece you will have to fix is this one:

Just remove the screws and prevent the knob to touch the actual button in the mouse. I did something very simple for that:

Put everything back together, plug both sides again (it took a lot of time for me becaues I removed the piece and had a hard time to put it back, be sure to do things right 😅):

Now you fixed the problem that shouldn't exist if Logitech took their hardware seriously. ✌️

Opinião: Produtos e contratações globais

Unknown — Sat, 20 Mar 2021 00:00:00 +0000

Tudo começou com uma discussão no grupo off-topic do Ruby Brasil. Alguém compartilhou a seguinte imagem:

Encontrei o post original no Linkedin

Esse post não é uma resposta direta ao Bruno Pereira, mas sim estendendo a discussão que começamos no grupo do Telegram.

Um dos argumentos usados lá é que as empresas precisam entender que esse é um mercado global e ligar com isso tentando fazer as coisas ficarem locais gera várias frustrações.

Uma das sugestões foi para as empresas começarem a contratar mundialmente, pensar em dólar e fazer o produto ficar global. Na teoria isso é uma ideia boa, mas na prática eu vejo um monte de problemas, por isso decidi escrever esse post.

O mercado global e contratação de estrangeiros

Eu acredito que o mercado de tecnologia é global e que o Brasil está brigando com empresas de fora do país por talentos. Eu mesmo sou um exemplo disso, já que trabalhei 7 anos para uma empresa grande de tecnologia brasileira e decidi trocar esse trabalho por um trabalho para o exterior. Nesse quesito, o post do Bruno Pereira é bem exato, pelo menos na minha experiência.

Vamos fazer um exercício de pensar globalmente. Na minha opinião, já vamos excluir qualquer país que tenha como moeda local USD, CAD, GBP ou EUR, já que o real vale muito pouco para qualquer um desses países. Eu não sei comparar o valor do real contra as outras moedas, mas seria um desastre em qualquer um dessa mais conhecidas.

Vamos usar um salário médio de um pleno/sênior (baseado em experiência, sem nenhuma estatística) de São Paulo para comparação:

Um desenvolvedor que ganharia R$15.000 aqui, ganharia ~2700 USD em um país que use essa moeda. Isso, na minha opinião, é um valor bem baixo para pagar um pleno/sênior.

Eu comentei de R$15.000 aqui, mas conheço startup que não consegue pagar isso direito e para pagar teria que ser uma pessoa bem sênior.

Sempre podemos nos aventurar contratando desenvolvedores de outros países onde nossa moeda não é tão desvalorizada, mas fico pensando no custo disso. A não ser que você tenha uma boa rede de contatos nesse país, vai ser complicado achar bons desenvolvedores sem tanto esforço.

Lembre-se que esforço e time to market também é custo e as vezes é bem alto.

Contratar pessoas de fora também vem com um monte de novas variáveis:

Risco de cambio
Barreira de idioma
Burocracias entre países
Empresas offshore
etc.

Produto global

Outra sugestão foi pensar em globalizar produto. No começo a sugestão era bem generalizada e isso gera um monte de problemas. Vários produtos são difíceis de fazer ficar globais. Tenho um amigo fazendo um produto tentando criar um "bolsa de valores de startups" (é o basement.io). Eles precisam conseguir regras específicas da CVM para regulação do mercado, ver se tem market-fit aqui no Brasil e mais um monte de desafios locais.

É possível fazer esse produto ficar global? Sim, provavelmente é, mas qual o custo? Fazer isso sem ter um produto provado e bem lucrativo é algo ainda mais difícil.

PS: estou usando a empresa como exemplo mas estou só assumindo informações da empresa, não sei se já acharam product-market-fit, se é lucrativo, se já tem tudo que precisa, etc. É só para exemplificar

Isso talvez funcione para empresas muito grandes, mas para empresas pequenas é complicado de fazer.

Pensando em empresas grandes, eu imagino a Locaweb aqui no Brasil. Ela tem alguns produtos legais e atende bem o público brasileiro, mas eu acho bem difícil ver a empresa brigando com competidores globais. Comparar as ofertas de plataforma da Locaweb com as ofertas da AWS (tem várias outras aqui, mas vou listar só a AWS para vias de comparação) é inviável.

Contratar dentro do Brasil

Me ver advocando contra times globais assim chega a ser estranho, já que eu sempre fui a favor de trabalho remoto e sinceramente acredito que é o futuro (por isso que trabalho para a Doist). O ponto aqui é que moeda e outros fatores atrapalham muito no processo.

Dito isso, contratar desenvolvedor somente local e não no Brasil todo é um erro, na minha opinião. Para mim era totalmente ridículo ter que ir para o escritório todo dia para poder fazer uma coisa que precisa de concentração e enviar para a internet.

Veja: a frase acima não diz que times locais são inúteis. Eles claramente tem algumas vantagens, principalmente quando a comunicação tem que ser rápida. O que eu estou dizendo aqui é que ter um time distribuído pelo Brasil tem mais vantagens que desvantagens.

Tudo o que os argumentos acima mostraram se aplicam bem quando aplicados dentro do país ao invés de considerar o mercado global. Alguns problemas simplesmente não existem:

A empresa é a mesma e as regras de contratação podem ser as mesmas para todos
Não tem barreira de idioma (ou timezone, mas eu acredito em async, onde timezone é menos problemático)
A moeda é a mesma
Você pode pagar mais para os brasileiros ao invés de ter que elevar salários porque a moeda te obriga a fazer isso para pagar um salário decente

Conclusão

Eu acredito que é um mercado global, mas acho que tentar brigar com o mercado global contratando fora do Brasil só é uma ideia legal na teoria.

Contratar pessoas para trabalhar remotamente em todo o Brasil é algo que eu venho falando nas empresas que eu trabalho e dou consultoria nos últimos 10 anos. É claro que isso exige uma mudança de cultura da empresa, mas para mim essa é uma mudança boa e que deixa a empresa mais resiliente.

Falando sobre a pirataria

Unknown — Wed, 17 Feb 2021 00:00:00 +0000

Há alguns dias atrás, um amigo meu compartilhou um texto sobre pirataria no twitter. O texto possui o tema "Precisamos falar sobre a pirataria" e pode ser visto aqui.

O texto é bem leve ao falar do assunto e mostra a visão da autora e sua própria experiência com a pirataria. Se eu fosse resumir o texto em uma frase (sim, é o meu entendimento sobre ele), seria:

Todo mundo já usou pirataria de uma forma ou de outra quando não tinha dinheiro o suficiente para pagar por um determinado material. Para muitas pessoas, esse é o motivo de elas estarem onde estão.

Não é a primeira vez que eu discuto esse tema, já tive várias conversas muito boas com amigos sobre isso, mas nunca escrevi a respeito. O post da Letícia e o tweet do InfoSlack me incentivaram a escrever esse post.

Minha relação com a pirataria

Como a Letícia escreveu, muitos de nós já usamos pirataria no passado e eu não sou exceção. Seja para estudar (livros) ou só para entretenimento (filmes, jogos, etc). Isso aconteceu comigo e acontece com outras pessoas por vários motivos. Vou listar alguns:

não tínhamos dinheiro para comprar o produto original
não víamos valor em pagar aquele preço
porque era mais cômodo piratear

Por muito tempo na minha vida, 1 era minha única opção. Quando eu trabalhava fazendo instalação de portas e batentes de madeira em construções e ganhava R$20 por dia, era o que tinha. Lembrando que isso foi em 2006, nem YouTube tinha e a internet era discada.

Com o tempo fui conseguindo receber mais dinheiro, mas eu ainda estava em 2. Eu não entendia nada desse lance de pirataria. Para mim, era importante eu ter o que eu queria, independente de quem criou o conteúdo. "Acha que eu vou pagar X nisso? Com esse dinheiro eu faço Y", era um dos jargões.

O 3 era sempre muito presente na época também. Tudo era muito complicado, não importando se estávamos falando sobre jogos, filmes, livros, etc. Algo muito diferente de hoje em dia, onde é muito fácil comprar coisas e há muito conteúdo bom com preço baixo.

Com o tempo, o mundo foi mudando e eu fui crescendo junto com ele. Aos poucos fui entendendo que o meu suporte aos produtos que eu gosto é fundamental. Alguns eu ainda não tinha/tenho condições de pagar, mas ao invés de piratear, eu escolho outra vertente de produto.

Já aconteceu de eu baixar um audiobook (sou fã de audiobooks) pirata, ouvir, e depois comprar o livro só para remunerar o autor. Nunca li o livro físico e procurei pessoas para doá-lo.

A visão de um criador de conteúdo pago

Eu sou um dos autores que cria conteúdo pago. Eu tenho meu livro publicado pela casa do código desde 2016.

Esse livro deu um trabalhão para ser escrito. Eu dediquei 315 horas do meu tempo a ele (mais detalhes sobre o processo de escrita aqui) e eu escolhi fazer desse livro um conteúdo pago.

Eu fiz inúmeras palestras sobre o conteúdo desse livro. A palestra é quase o mesmo conteúdo e foi gravada várias vezes, podendo ser vista no YouTube. O conteúdo da palestra é conteúdo gratuito, que eu fiz e ainda faço. É tempo que eu dedico para fazer conteúdo gratuito.

Veja, é importante mencionar que eu, como criador de conteúdo, escolhi dar coisas de graça para ajudar as pessoas. Eu também decidi criar conteúdo pago que exigiu muita dedicação para fazer. Ainda assim, as pessoas procuram na internet e pegam o conteúdo pago sem dar nenhum valor ao meu trabalho.

Remunerar o autor que escolheu dedicar parte do seu conteúdo para reverter algum dinheiro chega a ser uma questão de respeito, caso você realmente goste do conteúdo.

Lembrando que esse não é um livro de faculdade, daqueles que custam R$ 800,00 e é livro de leitura obrigatória da matéria X de um professor renomado. É o livro que eu, desenvolvedor de software, deixei de ficar com a minha família e amigos no meu tempo livre para escrever e que custa R$ 30,00 o ebook. Sai mais barato que uma ida ao cinema + pipoca hoje em dia.

É claro que para algumas pessoas isso pode ser o valor de um almoço e o preço de ficar com fome por estar desempregado. Não acho que vá ter uma grande quantidade de pessoas nessa situação, mas se você está desempregado e conseguir me convencer que você precisa do meu livro para conseguir o emprego que você precisa, entre em contato comigo que daremos um jeito.

Minha conclusão sobre esse assunto

Hoje em dia, com a quantidade imensa de conteúdo disponível na internet, muitos argumentos caíram por terra. Para conteúdos comuns (não conteúdos específicos exigidos por faculdades, por exemplo), a abrangência de material para ler na internet é bem grande. Dizer que não conseguiu aprender porque não tinha material disponível sobre o assunto é bem complicado.

Talvez você não tenha o melhor material em mãos porque ele é pago, mas você certamente consegue crescer bem com material online.

Muitas vezes seu autor/autora favorito pode ser bem acessível. Se você realmente não tem condições de comprar um livro de custo baixo (exemplo: R$ 30,00), entre em contato com ele/ela e conte sua história. Muitas vezes o próprio autor pode te fornecer o livro de livre e espontânea vontade.

Até mesmo para conteúdo em outros idiomas. Hoje em dia temos ferramentas de tradução em um nível bem aceitável. Pode não ser tão conveniente, mas é totalmente funcional e aceitável de se usar. Se não acreditar em mim, olhe algumas páginas em inglês nesse blog e clique na bandeira do Brasil que está logo no início do post. O que você verá, é trazido a você pelo Google Translate 😉.

Eu acredito que há casos em que as pessoas precisam mesmo do conteúdo e não podem pagar, mas estou convicto que isso é uma quantidade muito pequena dos casos de pirataria, e para esses casos, há formas muito melhores de lidar.

O que eu mais vejo é gente empregada achando legal compartilhar conteúdo pago gratuitamente por aí, e isso não é legal.

Thoughts on group chats

Unknown — Sat, 13 Feb 2021 00:00:00 +0000

I'm a big fan of group chats. The current app I use the most for group chats (and direct messages as well) is Telegram. I even created some group chats for topics I like (mechanical keyboards, note taking and productivity, Books and audiobooks, Money and investing, etc.).

I take group chats (and communities) more seriously than I should and I make sure chats are moderated and following their topic, otherwise, it wouldn't make any sense to have chats split by topic. 🤷

Throughout the years, I faced many interesting situations and I'm going to use this post to let some opinions free to face the outside world. I may update this post at my own will to reflect my current opinions. 😉

The case for focused group chats

I'm doing focused group chats for a while now. People tend to create "friends" group chats. These groups are usually people who know each other and want to stay in touch. Nothing wrong here, but it's usually not for me.

These non-focused group chats are usually noise with a variety of different topics which is not interesting to everyone. When people start to complain about random topics being discussed, someone usually asks:

Hey, why not using [Slack, Discord, Zulip, etc.] to be able to separate topics?

Although it may solve the problem, I tend to ask:

Why not creating many public group chats here [usually on Telegram] instead of restricting this conversation to a specific set of people?

That's what I'm doing in the past years and it's been a successful experiment. Even if the group is mostly the same when it starts, it's nice to see other people joining and the group becoming heterogeneous.

Public group chats should be communities

I have a strong sense of community, probably because I've been organizing meetup since 2007. To me, a public group chat is just another community and must be treated as such.

I still remember when I was into board games and decided to participate in some group chat from "board game communities" in my country. There was even a buy/sell group that seemed pretty interesting. I still remember when one member (the owner of the group) pinned his own sales ad to the group chat (over many others). I asked why he was doing this and many people just said: "It's his group, he does what he wants". That's when I realized this is not a community and I was wrong for being there.

Instead of creating my own board game community, I just gave up interacting with people from "the board games community" 🤷

If you have public group chats, please, be welcoming and fair to everyone. You may not know it, but you are a "community" now.

What to do if you're attending focused group chats

If you're going to talk about off-topic, don't.
If you really want to talk about off-topic, check if the group chat already has a off-topic spin-off. People usually do that to keep the main group focused so people can talk about whatever they want in the off-topic spin-off.
If someone complains that the current topic is not on-topic, just stop. There's no need to argue. If someone is complaining, is because it's not on-topic enough. On-topic would just be naturally accepted.
You don't know if "topic X" is on-topic? Start your message asking if it is on topic enough and someone will tell you otherwise.
If you have a question for someone in the group but you don't think the answer will be useful for other people, just send the question via DM.

What to do if you're an owner and/or moderator of a group chat

Make sure to write what is your group about and what is acceptable. If the description of the group is simple enough, you don't need to describe further.
You may assume the best from people but if your group is growing to dozens of people, it's inevitable to have a code of conduct to maintain a safe environment.
Kick/ban must have a warning prior to it. A simple warning may do the job. Point to the code of conduct being violated. If the behavior continues, kick/ban is necessary. Not warning people about this before banning is just bad.

Conclusion

There's no right or wrong (as usual), but I wanted to make sure some of my opinions about this are public so I can show it to people when they ask what I think about certain behaviors.

Chrome: Invalid HTTPS in development

Unknown — Thu, 17 Dec 2020 00:00:00 +0000

It's not the first time I had to use HTTPS for local development and had to do the whole setup of self-signed certificates. It's a painful process that doesn't have a good ROI for the developer.

One day, after being sick of doing this every time, I decided to do some research for an easy way to workaround this. That was when I found the thisisunsafe hack.

If you're using Chrome (or chromium) you can type thisisunsafe when you access your development app complaining about HTTPS certificates. Chrome will then bypass the HTTPS checks and just let you use it. 🎉

You may be asking yourself: "Where do I type this? The address bar?". It may look weird, but you type it anywhere in the page. You don't even see what you typed. It's not user-friendly on purpose. :)

This was life-changer for me. No more self-signed certificates.

PS: keep in mind that this trick must only be used for your development environment! Do not use it for real sites on the internet.

I wish I had something like that for Firefox, but unfortunately I couldn't find an alternative that is quick and dirty like that. Meanwhile, I will just use chromium when developing an app that needs this.

GitHub CLI (a.k.a gh)

Unknown — Tue, 15 Dec 2020 00:00:00 +0000

The GitHub CLI is been a major time saver for me. I was skeptical about its usage in the beginning but it proved to be very useful.

Cloning

When I want to download a new repository, instead of typing the whole URL or going to the browser to find the repository, I just type:

    gh repo clone name-of-the-repository

It works out of the box if the repo is mine. If it's from someone else, I have to specify the user:

    gh repo clone rust-lang/rust

It works like a charm ✨

Creating PRs

We create pull requests all the time at Doist, so it's great to have some automation for that.

I'm usually very descriptive on my commit messages. If the change is simple and just contains one commit, gh creates the description by itself:

    gh pr create -f -a PotHix -r nameOfTheReviewer

I even created a simple bash function to make it quickier when I use the following arguments:

create_pr() {
    local reviewer=$1
    gh pr create -f -a $GITHUB_USER -r $reviewer
}

After writing a good commit message, I just type:

    create_pr Doist/integrations

This command creates a PR and adds Doist's Integrations team as the reviewer and adds me as the assignee.

This has been saving a ton of time for me. Hope it's useful for someone else. :)

Assembling an Iris Rev4

Unknown — Thu, 23 Jul 2020 09:48:21 -0300

It's been a while since I'm looking for a keyboard that would be great to take with me when I'm not working from home for some days. I finally found the Iris keyboard that seems to be exactly what I'm looking for.

The need

I currently have a Kinesis Advantage at home. The keyboard is great, probably the best keyboard I used so far, but it's far from what we can call portable 😅. I needed a keyboard I could take with me when I wanted, so I started a quest to find it.

I bought a typematrix keyboard but it was not good enough (not even mechanical).
I had a HHKB Lite but I wanted a mechanical keyboard (it uses rubber dome).
I bought a Pok3r keyboard but it was too heavy for what I wanted.
I bought an Atreus keyboard but found that a 40% layout was too small for my needs

Then I found the Iris keyboard, which seems to be the perfect size between the Atreus and Kinesis keyboards. The problem is that it's a DIY keyboard and I had zero experience with anything electronic.

Talking to some friends I found that the Iris is the easy mode of DIY keyboards, so I decided to give it a try.

Pieces and prices

I had to buy the following pieces to be able to do it:

1 x DSA Keycaps: $23.50
5 x Cherry MX Clear Keyswitch (10 pack): $50
1 x Iris Keyboard - Case/Plates: $27.99
1 x Iris Keyboard - PCBs for Split Ergonomic Keyboard: $59.99
1 x TRRS Cable - Black Coiled: $7.98
Shipping costs: $6.10 (keeb.io) + $30 to ship it to Brazil (the final value is R$125 in my local currency)
1 Multimeter: R$37,00
1 Soldering kit (soldering iron, desoldering pump, soldering iron stand, tin wire tube): R$88,00
Acrylic Middle layers: $30.00 (bought after the keyboard was assembled as it's optional)

The sum is about $234.60 + R$125,00 (~30 USD). I believe I spent around 280 USD to build the keyboard. In my local currency, using the current conversion (it may have been different when I first bought the needed components), it's around R$1400,00.

I had some credits on Amazon and the currency was not that bad at the time. The effective value considering the credits was about R$800,00 which is still almost 4/5 of the minimum wage here in Brazil.

Assembling

Again, I would like to mention that I had 0 experience with anything electronic, so it was a amazing how noob I was. :)

This was my first soldering. Not something I'm proud of but something I laugh about today.

A friend of mine recommended me to use a fan to avoid inhaling the melted tin, so I was doing that. It just took me a while to realize that my fan was actually cooling the tin and the soldering iron making the whole process harder to do. If this is your case, be careful with your fan.

It's recommended to first do the soldering for the corner switches so it's easy to change anything in case the position is wrong somehow.

I first checked if all the connections for the switches were working correcly. I just used a tweezer to close the connection and get the signal on xev. Keep in mind that the fn keys do not emit any signal and it doesn't mean it's not working. 😉

The four switches were soldered and I did the initia mounting to be sure everything is in place. I'm using brown switches for almost all keys, except the modifiers where I'm using outemu purple switches.

It seems like a planned change but I did that to avoid buying another set of switches and a friend (thanks rhruiz!) kindly gave me these outemu purple to complete my set.

It's time to insert all switches.

Soldering time! The soldering is not great but it's the best I could do on my first attempt. :)

The left side is done!

Testing all the switches using xev just to be sure the soldering is working (spoiler: it is!)

It's time to do the soldering on the right side. Same process.

Now that everything is in place, let's add the keycaps.

Here it is! The first version is done! 🎉

It's expected that some keys will stop working after adding the keycaps, especially in my case since my soldering skills are not good. I went one by one and found some malfunctioning keys, so it's time to get back to soldering.

That's it! Everything done for now and the keyboard is usable already!

PS: Here is the album with all pictures I took while assembling the keyboard. 😉

Debugging

At some point I started having some weird behaviors like this "heaven and hell" LEDs:

And after some time the keyboard just got disconnected with a yellow LED light:

After disconnecting, the keyboad was not responding anymore. No LEDs, no dmesg message or anything. :(

I used the multimeter to do some basic continuity tests (thanks for the guidance @rhruiz) but found not short circuit or anything like that. After some time and a RESET while plugged, the keyboard went back to life, showing itself again on dmesg.

I saw a dmesg message complaining about the USB cabe and we (me and rhruiz) have a feeling the max brightness on both sides was too much too handle. 🤔

After all of that, the keyboard was reborn and baptized as Telperion:

It's important to keep in mind that DIY keyboard will certainly require some sort of maintenance from time to time. This is especially true if it's your first keyboard (as it's mine!) because your soldering may not be the best and it will require some small resoldering fix after some time.

Customizing the firmware

The first thing to do is to clone the qmk firmware repository. I suggest forking it and cloning your own fork since you will probably change it. 😉

After cloning the repository, you have to install the software needed to compile and flash the firmware. There are two (maybe more) ways to do that:

You can use docker via util/docker_build.sh script. It would be something like: util/docker_build.sh keebio/iris/rev4:default:flash
You can install all the tools locally via util/qmk_install.sh and flash with make keebio/iris/rev4:default:flash

I would love to use the option 1 but for some reason docker cannot find the keyboard via USB and I had to install the tooling locally. I suggest you to start trying docker and if it didn't work, go for option 2.

Compiling your own keymap

I created my own keymap inside my fork so it would be easy to keep the main code updated. So I have to use the following command to compile it:

make keebio/iris/rev4:pothix

If everything goes right, I just can just flash it.

Connect the keyboard to the USB port and hit the RESET button. It may be via RESET button at the back of the keyboard of actually hitting the RESET key on the "LOWER" layer (check the default keymap for more info).

After that, run the following command:

sudo make keebio/iris/rev4:pothix:flash

I'm not able to flash it without sudo, so keep it in mind when flashing.

Remember to flash both sides because you may get incompatibilities and weird behaviors sometimes. Here is one I had:

Optimizing

Depending on what you're using on your keyboard, you may exceed the maximum size for the binary. If this is the case for you (as it was for me :P), you can start disabling features you're not using.

This article was very helpful for me to understand what can be done. If you want some examples, check my rules.mk and config.h.

Conclusion

It's not cheaper to build your own keyboard as one would expect, but it's definitely fun if you want to get your hands dirty with soldering to build something custom for yourself. I learned a lot in the process and I hope to be able to maybe build another keyboard in the future.

It will probably not be the last keyboard I will build. I still want to build a dactyl-cc at some point to take the place of my current Kinesis Advantage. It's a handwired keyboard, so I will have to move to the hard version of keyboard assembling. :)

Happy keyboard building! ⌨

Contributing to Rust

Unknown — Fri, 22 Nov 2019 00:00:00 +0000

I'm involved with the Rust community for a while now. I'm one of the main organizers of the Rust meetup in São Paulo and also the Rust conference in Latin America (Rust LATAM) for more than one year now, but did not contribute to Rust source code yet.

This post will show the step by step I did to submit my first pull request to the Rust compiler.

If you want to go straight to the step by step, without any introduction, jump to My step by step to the first contribution.

The dream

I don't know about you, but I always wanted to contribute to core things. I still want to have a commit on the Linux kernel someday, and it's not the first time I try to contribute to a programming language.

I read the kernel source code multiple times and also read their contribution guides, but it's not simple to contribute. It's hard to find issues you can understand, reproduce, and compile. It may not be true for people out there, but it was my personal experience.

I also tried to contribute to the Ruby programming language. I was working with Ruby for many years, so I decided to read its source. I didn't find the code easy to follow, and the issues are not easy to find and reproduce. For Ruby, it's even worse, since some things are still in Japanese, especially the discussions. The language community is not very accessible to contributions like the rest of the community.

These paragraphs are not to say bad things about these communities. I still love Linux and the Ruby programming language. I just want to show my previous attempts and what went wrong. 😉

The Rust scenario

Different from the Linux kernel and the Ruby programming language, the Rust programming language is implemented in Rust itself (instead of C), which makes things even better. 🙂

The community and contribution guides are both awesome. You can feel the enormous amount of work the community puts on documenting stuff so people can find it easy to fix small things or even suggest and implement significant features.

The whole process of how the community organizes itself is very open and encourages everyone to take part in it. This is not something I found on my previous attempts of contributions.

How it started

At Doist, we (speaking about my team here) try to encourage people to learn new things every week. You should reserve some time to try new things and bring some knowledge back to the team. If you don't book work time for that, you will probably overwork or never have time to improve your development skills.

Every week we're naming someone to be responsible for describing what he/she learned during our next weekly meeting. It doesn't mean this is the only person that has to learn something, but at least one will be responsible for describing to the rest of the team.

During the past week, I volunteered to take some time to learn something and report back. What I have in my schedule for months now (I would say more than one year) is to contribute anything to the Rust compiler. It doesn't matter what the contribution will be, but it has to be something meaningful and change the compiler in some way.

With some work hours reserved (around 3 hours of work during the week) and some of my free time, I was ready to start!

My step by step to the first contribution

PS. I will link to a lot of documentation here, it's possible that they will change the links and it will break, but hope the whole context helps if the links are not 100% functional after some time

Understanding the structure

The first step was to read the CONTRIBUTING.md file. There's a lot of good stuff there. Seriously, it seems obvious, but it's not like other projects I tried and gave up quickly, it shows/points to everything you need to know.

If we refer to the build system section, we will be quickly introduced to the build script (x.py) and to a complete guide about how the compiler works! :)

From there, you will understand how the compiler works and how you can use the python script to build a small piece of it, which is what you want to be able to fix a bug.

Finding the issue

I'm particularly interested about the diagnostic issues, so I reached out to the guy who is more familiar to this part of the codebase (@estebank) via Zulip, which is currently the tool of choice for communication with the compiler team.

I met Esteban at Rustconf and Rust LATAM, so it was easy to introduce myself (again). Everyone I talked to until now was very receptive to help when you're polite (of course) and asking for help, even if they don't know you, so don't be afraid to reach out to people.

Esteban described which labels would be suitable for my first issue (in this case, d-papercut), and I started to read one by one to pick mine.

After some time, I decided to investigate an issue about the suggestion for the #[repr = "C"] syntax.

The first compilation

The issue I chose mention a .stderr file on the codebase, which is a great way to start. :D

The first thing I did was to look for one of the strings I found there (the text "must be of the form") and change it to something else.

I changed it to must be of the whatever and referred back to the documentation on how to build the compiler.

As a side note: The way the compiler is compiled is very interesting. It has three different stages. It downloads the beta compiler to compile itself (Rust is written in Rust, remember?), and then it uses the generated compiler to build the compiler again against itself. :) (there's much more, but I recommend reading the official documentation if you're interested ;) ).

After trying some commands to build the repository and get used to the time it takes to compile (and how to make the compilation faster by compiling parts of it), I got my first version of the compiler and was able to compile a sample program.

I have to say that it's very satisfying to see the change you did there. It doesn't matter if it's just a string. It proves to me that the first step is done, and it's realistic to continue. o/

Now that I can build the compiler, I can get back to the issue and modify the mentioned test.

Testing the compiler

We will now use the rustc documentation again to understand how to run the test suite for the compiler.

The documentation helps to understand how the testing organization and infrastructure works. It also shows the various types of tests you will find and how to run them. In my case, I had to run the UI tests of the compiler, so I could run it using the x.py script just like I do with everything else:

./x.py test --stage 1 src/test/ui

PS. I will not go into the details of the code I used since you can refer to the documentation I linked and get a much better and detailed explanation.

While trying to understand how the testing infrastructure works, I found a problem with the documentation, so I submitted a PR to the compiler doucumentation and it was accepted. 🎉

Now, getting back to the issue. When I ran the test command, it shows me that I now have a broken test, since I changed the word form to the word whatever. \o/

So, let's first fix the test to have the behavior I wanted. In this case, I want to recommend #[repr(C)] to everything instead of a statement that is not valid. By doing that, the editors can suggest valid code instead of just a tooltip with and list and ....

Now that I have a broken test, I can checkout the code file and start looking for the file to change.

Understanding the code and changing what's needed

This is the part where we should be more used to. When I say more used to, I mean it's more related to our day-to-day job, whatever it is. It's just another codebase with a bug that you have to find out. 😉

Let's start debugging it function by function and understanding which code is being called. We will do that until we find the piece of code that has to be changed.

While you're going up the stack, you will probably find many other things you have no idea how/why they are there. In some cases, you may see features of the language that you're still not familiar with, so you may also take some time to learn those to continue your journey. That was the case for me with macros. 🙂

After some time, I finally found the place I had to change, and it was simple for this particular case I was trying to solve.

Creating the pull request

To create a Pull Request, we can refer to this section in the Rust documentation. I used that to create mine and mention Esteban.

There are some bots to help the community to take care of managing the PRs, so we (as a community) have many powers to ask for reviews, approve PRs, create a queue of PRs to merge, etc.

To mention someone to review, I used the r? @username function of the rust-highfive bot, so it can assign the person who is knowledgeable on that part of the codebase (@estebank in my case).

After creating the PR, the Rust language infrastructure will run the tests (it was Travis before, Azure pipelines currently, and may change to Github actions in the future) and report back in the PR.

After some time (~2 hours), I got the report that I broke the build with my changes (🤦) because there were other tests in a different part of the code, expecting that message as a diagnostic for the [repr = "C"] syntax. I checked the code again and just fixed the test.

PR and discussions

As usual, there was some discussion about the change. The PR usually stays there for some days until one of the maintainers have enough time to take a look at it and decide if it's worth changing.

The discussions usually happen on the PR itself, but in my case, there were some discussions with Esteban via Zulip, as the change was straightforward, and I had some questions.

It turns out that my change only partially fixes the issue because it will need something better designed for this case. The idea is to suggest the right repr for the context of the code. This change will take much more knowledge (and time 😅) than I have now.

Fortunately, the Rust team found the change to be valuable enough to merge in, even if it doesn't fix the issue altogether, so the PR was approved !

After the approval

When your PR is approved, the @bors bot will add it to the the queue of PRs to merge and will eventually be merged to the master branch.

You will also be added to the Thanks page as you're now part of the Rust repository with you commit 🎉.

Next steps

I like to do it in baby steps. I planned to try something simple, so I could understand the basics of contributing to the compiler. It's now done. 🙂

Now that I (and hopefully, you as well) understand the processes to contribute and have the setup to do it, I can go to the next step and try more issues. The plan is to focus on the diagnostics part of the compiler (which is the part I like the most) and solve small issues that may have a high impact on how the developers are interacting with the language.

When I feel comfortable with the small issues, I can look for something bigger... but... baby steps. 😉

How was Rust LATAM 2019

Unknown — Sun, 21 Apr 2019 14:02:54 -0300

For those who don't know, I'm a proud core organizer of the Rust LATAM conference. 🎉 The conference happened on March 29 and 30, and this post describes how it was to organize the whole thing.

Even with the small problems we had (as any other big conference), the feedback we received so far were very positive. We were able to bring amazing speakers to the conference, which brought high-level content even for beginners.

Organizers

This post does not name people because I don't know how much they feel comfortable to be mentioned here, but there's someone that needs to be mentioned, and this person is Santiago Pastorino. As the conference happened in Montevideo (Uruguay), Santiago was the main organizer and main contact to everything local to the place. He was the one doing the heavy lifting for most of the things related to this conference, and he has my full respect for that (and many other things).

Don't get me wrong, we (other organizers) did some hard work too and I would mention others by name. We joined in different stages of the conference organization and committed ourselves in different levels, Santiago was the only one who started it and was there until we delivered it with the same level of commitment, that's why I decided only to mention him by name.

I made some new friends while organizing this conference. It's great to see how you become friends with someone after you spend some days doing hard work and feeling the same pains and joys. At the end of the conference, I felt I knew these people for years already, and it was just 4-5 days working together. Of course, we had many interactions via internet, but it didn't happen to all of them, and it was less intense. I would say that the level of commitment to the same cause is proportional to the bonding of the friendship.

Attendees

We generated a chart about the demographics using the data from everyone who attended the conference. Here's the data we have for that:

Errata: After the conference someone noticed that Mexico was not included in the legend of the demographics chart when we presented in the opening speech, so I'm posting the right data now. It was my fault, sorry Mexico! The Rust LATAM community loves you! 🇲🇽

60%+ of the participants were Uruguayans. We were expecting that already since many of them were students. We did (Thanks Santiago!) some presentations at local universities to promote the conference and the language.

We didn't have any problems with any of the attendees. Everyone behaved as expected for the standards of the Rust community and I hope many met some new friends to exchange information about Rust.

Rust still has a small community in LATAM, but we're trying to make it better with this conference. :)

Speakers

Here I'm also counting the workshop speakers not only the ones who were speaking on stage on Saturday.

In the end, everything ran smoothly with the speakers. One speaker was not feeling well during the conference and we were worried about this person and also for the possible slot e would have to fill but the speaker was able to deliver the talk (which was great, BTW 😁).

All speakers performed great (even when Apple Keynote decides not to cooperate 😜) thanks a lot to all of you that gave us your time and knowledge to make this conference happen. ❤️

Brazilians

Yes, Brazilians deserve a topic. :)

For those who don't know yet (for some reason), I'm Brazilian. It's not so common for people in Brazil to go to different countries (I may be generalizing, but that's my feeling), mainly because Brazil is so huge. I was amazed to see we had more people from Brazil than people from Argentina there. 🎉

It's a common thing to have this "Brazil x Argentina" thing (because of soccer...), so I was joking about the number of participants. To be honest, I was happy to see that we were considering each other as fellow programmers of the Rust LATAM community and not people from country X or Y.

We have a Rust Brasil chat on Telegram that has 600+ members. There we have members from many different Brazilian states; it's a place to unite all the local meetups like Rust-SP (São Paulo), Rust-BH (Minas Gerais), etc. It was the first time we had a more significant meeting where people from different places could come to meet and talk to other Brazilian Rustaceans. We had an internal joke that it would be the first meeting of Rust Brasil...in Uruguay!

What went well

The whole conference went well. We feel that people are satisfied with what we were able to deliver. We collected some feedback and the general feeling was excellent.

It seems we were able to do everything on budget as well, so we didn't have to spend our own [personal] money to deliver the conference and help speakers and organizers to get to Uruguay. This was only possible because we had amazing sponsors to help us with that. Thanks Rust LATAM sponsors!.

We were able to deliver a pre-conference meetup, one day of workshops, and one day of talks. Considering the size of the team and how busy we were, it was almost a miracle (IMO). 🎉

The venue for the conference was great. We didn't have any problem at all with it. Thanks a lot to Antel for providing it.

Problems we had and What has to improve

Of course, there were many problems. The simple ones, the complicated ones, the funny ones, etc. We hope they were not apparent for the participants and speakers. :)

Number of organizers and commitment

We had fewer organizers than we wanted to have. Some of us were able to commit more than others, so we had to bring more people to the core group of organizers. Some of us had to leave the group in the middle of the process because they were too busy with other things; others were there but not able to do much. This whole situation made everything even more difficult.

Next time we should probably get more people and more commitment in the beginning so it will be easier to afford losing people in the process without overwhelming everyone.

Food and places

We had some problems related to food and the usage of one of the workshops place. We paid for something and it was delivered in a different way than what was agreed. There was probably some miscommunication in the process, but it's hard to know how much of it was on purpose or just unprofessional.

Intro to Rust Workshop

The initial plan was not to have any wokshop, but we were considering having one done by us. In the end, we got awesome people to deliver workshops, and we could have spared ours.

After some discussion, we thought it would be great to deliver our workshop still because there were many students enrolled and it would be a good thing for them. It proved to be accurate because it was the biggest workshop we had.

The only problem is that it had to be delivered in Spanish and we had just two native Spanish speakers organizers attending the conference. Santiago became the responsible for the workshop.

The problem of having Santiago doing the workshop is that he was already doing all the other things that needed someone from Uruguay and didn't have enough time to work on it. We slept less than we wanted and finished the whole slides and exercises together in the day before (which reminded us of our university times! LOL).

We already had the content for the workshop, but now Santiago was "trapped into a room" for the whole day. Many things were only known by him (contracts, discussions by phone, etc.) because he was the one dealing with locals. Well, in the end, he became the single point of failure of the conference.

We managed to fix everything by covering him during the workshop exercises but it was not an easy task to do.

It was great to have an Intro to Rust workshop, but we did not plan it in the right way. Next time we will probably have someone other than the main organizer doing that! LOL.

Backstage stories

Well, we have some interesting stories from backstage to tell you. 😁

Having fun with the language mess

It was hilarious to have Italian, English, Spanish, and Portuguese all mixed up between the organizers and locals. We used English as the lingua-franca between us (where's Esperanto? :P) but we also had to deal with locals that only speak Spanish (venue, catering, etc.), so we had to switch languages from time to time.

I remember when one of us was speaking Italian to the Spanish speaker organizer by mistake. His face was: "Why is he not understanding me?". Very funny.

There was also one time when we were discussing the workshop (2 AM) and the Spanish speaker read something in Spanish in an e-mail and after that, this person made the switch to Spanish while we were looking to him/her laughing and trying to understand what he was talking about.

I have to say that I had a lot of fun with these situations :)

Lost backpack

We were using a rideshare app to go from one place to another. We had to bring boxes of t-shirts, bags, banners, and other things to the place we were staying. You can imagine that the logistics were not easy.

In one of these rides, one of us took the boxes but forgot to get the backpack from the car before leaving. We tried to contact the driver, but it's not that easy to do that using this app in Uruguay.

When we finally could get an answer for the driver, he said that there was no backpack there... That's nothing to do about it other than report it to the police.

Well, it was awful for the organizer (and for the whole conference organization), but it became even worse when we found that this person's passport was also in the backpack. We started the process of getting a new passport during the workshops day so him/her would be able to get home in time. It's a long and stressful process.

Trapped organizer

One of us was out to bring the tablecloths for the sponsors' table. When this person got to the place, it was almost closing, and he/she got trapped into the garage. One of us had to go there to release him/her but this person was able to release [him/her]self before we arrive. :P

Conclusion

Organizing an international conference is tough. It took a lot of my time in the past 3-4 months. There are so many details to consider, and sometimes basic things you consider as done comes back to bite you.

The feeling of accomplishing something that big with positive feedback is something that you take for life. I'm very proud of being part of the team that made it happen.

Well... The best way to end this post is to thank everyone (attendees, sponsors, speakers, organizers, etc.) who were there to make it happen. 🦀

PotHix ❤ Doist

Unknown — Mon, 30 Oct 2017 00:00:00 +0000

TL;DR: I'm working on something I really believe is good at Doist and I feel great.

As I mentioned on this post (in pt-BR) I left the company I was working for the last year to join a new company. The new company is Doist and I'm working for them since July.

Some time ago a friend asked me why I joined Doist and I realized it's kind of a love story so I decided to write the post. 😄

For those who are not aware of Doist, it's the company behind Twist and Todoist. Twist is a communication tool that aims to make remote communication work better for remote teams and Todoist is the best task manager I know.

I joined the company in July as I said but I'm a Todoist user since 2007 (this link requires yahoo groups membership, it's free but required) and I always recommended my friends to use it. I tried many task managers in these 10 years but I always get back to Todoist.

When I started my career as a software engineer in 2006, I decided to also look for a better way to deal with my tasks. My memory is not very good, so I decided to look for a system to help me with that and found GTD. For some time I was one of the moderators of gtd-br, probably the biggest GTD mail list in Brazil at the time and was looking for an application to manage my tasks.

I was looking for something clean, lightweight, simple, and with support to keyboard shortcuts. Tried Toodledo, Remember the milk, thinking rock, and some others but none of them were good enough. I was about to create my own when I found Todoist, it was exactly what I was looking for.

As an active user, I was always following the new features and the usage of new technologies in the product. I remember when they started using HTML5 for their mobile application, it was really great to see it.

At some point I found that a company called Doist appeared as the creator of Todoist (it was just Todoist before that) and I started looking to their job board. There were not so many positions and all of them required a good level of Python. My focus was always Ruby and I didn't have any experience with large Python projects at the time.

Some years passed and I had the chance to work on some Python projects at work and gained some experience. I even created a personal project in Python to do some scrapping for some financial data I wanted, it became a big project but it was abandoned after Google Finance implemented my main feature. :P

When the time for a change came I decided to apply for companies I admire and who believe in the same things I do. I also changed my mindset and decided to not look for technology anymore but for products I believe are really good and can recommend to my friends and family.

I worked for 5 companies in the past and none of their products were something I can really recommend to everyone. Most of them don't even exist anymore. Others are relatively good in one specific use case and country. I was working for these companies because there were great people, good salary/benefits, or great technology.

When I saw the position to "API & Integrations" developer at Doist I decided to apply. I was kind of insecure about the platform change (Ruby -> Python) but I believe languages are just tools to build stuff and I had enough experience to be proficient with Python. I also love to create tools for developers and did that in the past many times already, so it would be a great fit.

During the interviewing process I found that it was a perfect match of beliefs:

Remote working
Async working (not fixed hours, we believe you will do you job and will follow your metrics)
Chance to travel and meet different people/cultures
We read nice books and actually apply their concepts (radical candor, the score takes care of itself, let my people go surfing)
Bootstrapped company
Amazing perks for remote working
Almost the same salary I had

I was already doing remote work 70% of the time for my previous company and I also have a freelance job for a company in Netherlands, so I'm used to remote working already. With that said, I took the job. :)

Of course not everything is rainbows and unicorns, as everything in life, but the overall experience is really great. At this moment, I'm writing this blog post in the airplane (airplanes are the bad part :P), coming back from a trip where I met 12 members of the team (we're 50+ at the moment) in two different countries. I also was the person of contact for all hackers doing our challenge at the HackUPC hackathon in Barcelona, which helped me a lot to collect feedback of our APIs.

The whole thing about the "love story" I mentioned in the beginning of this post is that Todoist helps me since the beginning of my career and now, after almost 10 years, I have the change to work for the company behind it. What is even greater is that the company has the same mindset and beliefs I have.

For this particular case, instead of using technology to retain talent, Doist built the best product ever, which made me consider applying to make it even better.

My Archlinux setup

Unknown — Sat, 05 Aug 2017 00:00:00 +0000

I was playing with Archlinux in the last 3 or 4 years and last year I decided to reboot my configuration files and start using Xfce.

Talking to Fabio Akita about my Archlinux tunning, I heard that I should be posting about that. That's true, so I decided to start writing it. I wrote in March and it was in draft form since then, so it's time to release it. :)

BTW, Fabio already did that, but I will post about my setup anyway.

Desktop Environment

I was using Gnome before deciding to reboot my workstation. I met @marcosnils at Gophercon last year and we had some chatting about window managers. I'm a big fan of tiling and was planning to go to a tiling window manager again. The problem with tiling window managers is the amount of configuration you have to create in order to have your laptop in a fully functional mode. I was looking for something between a window manager and a desktop environment, something composable with some support for tiling. And then, he shows me his laptop with Xfce running.

That doesn't look like the Xfce I know. It was pretty smooth and with many features I did not know. Then, I decided to give Xfce a try.

At first, it was horrible but functional. I could compose its packages to only install what I wanted and almost everything was working out of the box. That's what I was looking for. So it's time for themes, fonts, bars and so on, just to make it beautiful.

Here is my results:

It looks good to me. :)

Xfce has shortcuts to do what I like to do with tiling: vertical and horizontal splits. Here is an example of me writing this blog post on a split screen on my ultrawide monitor:

Keyboard shortcuts for different types of screenshots were really useful as well. I did not know this feature, but it was probably my fault. :P

Window manager

I was trying different window managers at the time, so I decided to give i3 a try. It looks very good if you like (or have the time) to configure and tune it.

As I was trying different things, why not to try Wayland as well? So I installed sway instead of i3 to use it with Wayland. It was an interesting test. My configuration files work with i3 and sway currently.

I'm usually using Xfce but sometimes I log in with sway to take advantage of the tiling in a different way.

Managing configuration files

It's possible to use configuration managers for this task (like Salt, Ansible, Chef solo and so on) but I preferred to use a simpler way.

All configurations to recreate this environment is available in my dotfiles repository. It uses a project called dot-install created by Diego Souza. It is a simple bash script that copies the files to the correct places, BOOM, done. I like it.

I can create bundles to apply the same configuration files to more than one computer. Some files have to change because of network interface names and so on, but the structure is the same.

Kernel

I'm trying different kernels. The first one (and easier) was linux-zen. It is available in the community repository of Archlinux. I really recommend it in case you don't need (or want) to use Docker with support to overlayfs.

I was also compiling the rc releases of the Linux kernel whenever possible, so I could try to contribute in case I found something weird, but as it takes a lot of my time, I decided to give it a break for some time.

But the best one until now is the linux-ck. It is the Linux kernel with the patches from Con Kolivas. There is a different scheduler running and some other improvements. It was made with desktop performance in mind (just like linux-zen, that uses the same scheduler from linux-ck).

linux-ck has its own repo, in case you don't want to compile it yourself from AUR. Just add this line to your pacman.conf:

[repo-ck]
Server = http://repo-ck.com/$arch

Just be aware that the link quality is awful. You have to retry it many times to get the file downloaded. =/

Tunning

There are some good tips to apply on your Archlinux, but I will not just copy & paste it here. Please refer to Fabio post, since I discussed with him about it and we applied almost the same procedure.

The I/O related tunning are the most recommended.

Package manager

There are some addition package managers available for Archlinux, so you can deal with AUR easily. Fabio uses pacaur but I prefer to use aura-bin.

I know guys who prefer to use yaourt but I don't think it has good defaults.

Installing it from scratch

I'm that kind of Linux user who likes to install new distributions or rebuild the system from time to time, so I created my own ways to do it faster.

I decided to not automate the whole Archlinux installation because it would take more cost than bringing benefit. The partition of the disks and initial installation I do manually and then I use my own scripts and configuration files to get the same environment I had with just a few commands.

The first step is to install all packages needed to my day-to-day tasks. For this matter I have this script. It executes many commands to install all packages I need.

I run this script every time I decide to reboot my computer. So, instead of running systemctl reboot I run update-and reboot and it reboots with the new packages installed.

Conclusion

Since I started used Linux I've gone through Kurumin, Slackware, Ubuntu, and Archlinux. I formatted my laptop many times and kept using Archlinux for the past years, it's the best Linux distribution for my use case.

If you're looking for the best cost/benefit for customization and effort doing it, I really recommend Archlinux + Xfce. You will miss some new technologies on the WM side (Wayland...) but it worth the trade-off.

Wordpress to Middleman, to Hugo using github-pages and HTTPS

Unknown — Tue, 13 Jun 2017 13:54:49 -0300

Yes, it was a journey. I decided to chance my blog engine again.

But this time I decided to post about the whole transition, since I started my blog, back in 2008.

I needed a blog at the time but could not spend time creating something, I just wanted to "buy a blog" and write. Dreamhost was an awesome service for that. In one hour I bought a domain, installed a Wordpress via one click install and set up my own email via Google apps (at the time it was free).

Wordpress is a good blog engine, it just works. You have to keep it updated because of security risks, but it works. I wrote some plugins and customized themes during the years I used it and it worked just fine. Please, don't say bad things about Wordpress, it solved more problems and is great for so many people. :)

After some years I decided it was time to cancel my Dreamhost account. I had just some small websites there and all of them could become static pages. That's what I did.

All my website were converted to static web pages and migrated to Github pages, including this blog. But let's focus on this blog for a while.

Migrating from Wordpress to Middleman

I was already using markdown for my blog posts because I was posting from Vim using Vimpress. So I had to convert all other posts from HTML to Markdown.

My old layout was not good anymore. I was looking for something responsive and used the migration to get the courage to change the layout as well. I bought a Wordpress layout and converted it to .erb for Middleman.

I was using Wordpress comment system and I decided to not migrate to Disqus. Today I know that I could do that, but at the time I decided to just abandon the old comments. But I wanted to keep the names of everyone that wrote a comment in the article.

Most of the migration was done by a Ruby script that I created. These are the steps needed:

Download an .xml backup of your Wordpress posts with comments
Change the script to use the correct file name and blacklist comments
Run the script

The script will convert all posts from HTML to Markdown and create individual files for every post, following the middleman style.

You just have to check every post and fix images.

In my case, it was harder than that because I was creating a blog from scratch but using the same content. But at the end, it worth the work.

Migrating from Middleman to Hugo

For some reason, I decided to not post about my blog engine change this year. I was using middleman since May 2015, but decided to change to Hugo.

I promised myself that I would not change my blog engine to Hugo just because it looks cool. And then Middleman started to work weird, sometimes the middleman serve serves my content as plain text instead of HTML. It was hard to try it locally before publishing.

It was everything I needed to try a new blog engine (haha). This migration was simpler. I just had to understand how Hugo works and how the template language works.

To convert middleman format to Hugo I used a big sed command that I can't reproduce anymore. haha

As usual, I used the migration as an excuse to do more things. Since 2008 I change my URLs layout many times. So, I used Google Analytics to get these old URLs and added them as aliases in Hugo. The old URLs now work with the current blog.

Some advantages of Hugo:

It's just a binary, I don't have to install anything beyond that. (aura -S hugo-bin :D)
It builds *really fast, it's not fair to compare with middleman (Go X Ruby)
There are some great features, like aliases
I really like the live-reloading by default

HTTPS

I was missing the HTTPS feature, but it was not possible to use it when using Github-pages, at least not for custom domains.

After reading this post (pt-BR) I found that it would be possible to use HTTPS, even in Github-pages, and for free.

The solution: Cloudflare!

Cloudflare has a free plan that is sufficient for many blogs out there. You just have to create your account and point your ns entries to their servers. By doing that you can even use HSTS! :D

Conclusion

I'm really happy with the current setting.

Hugo is a great platform
Github is fast, simple and free
My new layout has the features I need
It's easy to change

Static pages are the future... again... haha

FOSDEM survival guide

Unknown — Mon, 06 Mar 2017 00:00:00 +0000

TL;DR: It was my first time at FOSDEM and it took some time to feel comfortable, this post may help newcomers.

As I mentioned in my previous post, I spoke at FOSDEM this year. It was my first time there (in the whole Europe, btw!) and it took some time to get used to the way the event goes. This post will show some tips that may help FOSDEM newcomers and maybe some veterans as well.

What is FOSDEM?

FOSDEM is the Free and Open Source Developers - European Meeting. Long story short, it's a big self organized event that happens in Brussels every year since 2013.

The conference has many Devrooms organized by volunteers with a predefined schedule guided by topic. Aside of that are the main tracks, that are some unique presentations happening in some big rooms.

The whole event survives from donations and some sponsors, but it's not organized by a company (like OSCON, for example). There are many volunteers that work hard to make it happen.

How it works

The conference happens at the Université libre de Bruxelles, using some buildings of the university.

All the tracks are spread across these buildings. Depending on where you are, you have to reserve some time to reach the other building. It is not so far, but may take 10 or 15 minutes depending on your location.

Think about the time it will take on the transition in case you want to watch as many presentations as possible. Also, plan ahead your time to be at the room because it may be full when you get there...

FULL rooms

FOSDEM is chaotic. It's is a good and a bad thing at the same time.

Conferences like these, organized by the community for the community, are the kinds of events I really like. They tend to be chaotic, but it means people are free to do whatever they want.

They can walk through the university and watch whatever they want. FOSDEM publishes a big schedule with information about all the presentations happening across all rooms and you may create your on schedule. I did it before going but forgot to consider the time between buildings and the "FULL" rooms.

There are some limits that need to be respected, one of them is the number of people inside the room. When the room is fulfilled with people they add a "FULL" sign at the door and nobody is authorized to enter. It make sense, but is really annoying for newcomers.

When planning your schedule, plan to get to the room at least 15 minutes before it starts.

TIP: instead of jump between many rooms, it's a good idea to choose one or two and stay there for 2 or more presentations. It will guarantee a spot for you in the room.

My schedule did not consider the time walking between buildings and the full rooms, so... could not enter in 4+ rooms I wanted to be in.

Lunch

There are some food trucks there. They do not give you a receipt (in case your company is refunding your travel, you may need it), so be prepared for that.

It tend to be crowded at peak hours (noon, maybe?), try to get something to eat before or after. But be warned that it is almost always crowded. :)

The conference don't have any breaks, if you want to eat something, you will have to decide to not watch a presentation and use the time for it.

Parties

They have a pre-conference party at Delirium. The bar is closed for conference members only (they ask some tech questions to get you in :P). It is not a huge place to have everyone in, so it will be really crowded and hot there. Almost the same amount of people will be chatting and drinking outside of the bar as well.

After the first day of conference, there is a second party, usually in a hacker space in Brussels.

Presentations

Always read the presentation description. Some of them has "click bait" (attend bait in this case?) title, sometimes not intended. I attended to one of them about a language development. I was expecting something about the day-to-day of the language development and what features are planned for the future. Unfortunately, it was not what I (and many people in the room) were expecting. It was about the metrics and dashboards of the language contributors and features.

In this case, it was not probably not intentional, but almost 50% of the room left before the presentation ended.

Conclusion

FOSDEM is a great event, I really enjoyed it! I would like to have received these tips before, so I would have planned my day better.

Hope it helps the 2018 FOSDEM attendants. o/

My presentation at FOSDEM 2017

Unknown — Sat, 04 Mar 2017 00:00:00 +0000

This year my proposal to speak at FOSDEM was accepted and I spoke at the Desktop devroom! :)

It was my first talk in English, so I decided to do as many rehearsals as I could. I was 8 in total, but as expected, it was still a little bit faster than expected. :P

I had 30 minutes to present and I did it in 26. I usually speak fast and this presentation was made to be fast because I had a lot of content to show in 30 minutes. So, it was FAST (even more than what I was expecting). LOL

I'm OK with the final result. It's far from being my best presentation but it's the first one in a different language, so it's acceptable.

They already published the video for my presentation, and it is available here as desktops_open_source_behind_web_request.

In case you want more information about the presentation, including the slides, you may want to check its page on FOSDEM Schedule.

FOSDEM was great, can't wait for the next! :)

Experiences of almost two years using Colemak

Unknown — Thu, 08 Oct 2015 00:00:00 +0000

TL;DR: I like Colemak, and it is a very good layout. I found some equivalent pros and cons, so I can't recommend it to anyone without a little bit of philosophy. :)

For those who don't know Colemak, it is a keyboard layout created to make the most used keys stay in the home row as well as make you swipe between your right and left hand.

There is a keyboard layouts heatmap for you to understand the benefits of using a keyboard layout that was designed to help you to be comfortable and fast when typing instead of one that helping the operator to not jam the typewriter. I tried some code (python), English and Portuguese texts and it looks almost the same on the heatmap.

I'm using Colemak since Dec, 25 of 2013 and here come the pros and cons that I found:

The first con is that I don't know how to type fast on Qwerty anymore, now I'm typing as I never saw a Qwerty layout before. The problem is that everyone uses this crappy layout and sometimes you need to use it to write and it makes you look like a grandpa. The good part is that I almost don't need to use Qwerty, all devices that belong to me I've changed to Colemak (computers, cellphones and so on), so I just need to use Qwerty when I'm typing on other peoples devices.

A pro is that my typing speed grew from an average of 75 WPM to almost 100 WPM. I need to consider that I also bought a Kinesis Advantage Pro;

Without this keyboard, I'm not that fast. Just tried 10fastfingers now and got 92 WPM using my laptop's keyboard.

Another pro is that I really feel comfortable using Colemak, you the same way as being an experienced Vim user, looks like you don't need to type so much. :)

Now, talking about Vim... I'm an experienced Vim user, but Vim is totally coupled with the Qwerty layout. I tried to remap some keys (like hjkl for example) in order to keep using the home row to navigate but it was not very good. Today I'm just using the plain Colemak layout on Vim and it is not so good as it was on Qwerty. For this reason, I decided to try a new editor and I'm using Emacs now. :)

It took me at least a month to get back to my old typing speed, I was training every day on 10fastfinges to get used to the layout. In the beginning, you may feed some headaches because of the mind remapping. It's not so easy to change something that you thought was the only way of getting things done. It was a great challenge for me and it just seems right, I don't wanna use a keyboard layout that was made to avoid jams on a typewriter, Jesus, we're in 2015 and there are no typewriters anymore.

Hope this post helps a lot of Colemak newcomers and the only thing I could say about my journey is that I would do it again if I could. :)

Ruby, Python e native threads

Unknown — Fri, 14 Feb 2014 00:00:00 +0000

Pode ser que eu seja meio burro (heheh) mas eu ainda achava que o Ruby e o Python usavam Green Threads, mas depois de conversar com uma galera me disseram que eram threads nativas. Pesquisando na internet eu vi que eram mesmo, mas decidi rodar um strace para ver elas rolando e postar sobre isso.

Fiz dois scripts simples:

Python

import threading
import time
for i in range(5):
    t = threading.Thread(target=time.sleep, args=(1,))
    t.start()

Ruby

require 'thread'
5.times do
  Thread.new {sleep 10}
end
sleep 1

Rodando o script python com o comando strace -f -e clone,fork python thread.py retorna pouca coisa:

clone(Process 13920 attached
child_stack=0x7f8570b67ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f8570b689d0, tls=0x7f8570b68700, child_tidptr=0x7f8570b689d0) = 13920
[pid 13919] clone(Process 13921 attached
child_stack=0x7f856bffeff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f856bfff9d0, tls=0x7f856bfff700, child_tidptr=0x7f856bfff9d0) = 13921
[pid 13919] clone(Process 13922 attached
child_stack=0x7f856b7fdff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f856b7fe9d0, tls=0x7f856b7fe700, child_tidptr=0x7f856b7fe9d0) = 13922
[pid 13919] clone(Process 13923 attached
child_stack=0x7f856affcff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f856affd9d0, tls=0x7f856affd700, child_tidptr=0x7f856affd9d0) = 13923
[pid 13919] clone(Process 13924 attached
child_stack=0x7f856a7fbff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f856a7fc9d0, tls=0x7f856a7fc700, child_tidptr=0x7f856a7fc9d0) = 13924
[pid 13921] +++ exited with 0 +++
[pid 13920] +++ exited with 0 +++
[pid 13924] +++ exited with 0 +++
[pid 13922] +++ exited with 0 +++
[pid 13923] +++ exited with 0 +++
+++ exited with 0 +++

Conseguimos ver claramente as 5 threads do SO aí em cima. :)

Já no ruby, rodando com o mesmo esquema (strace -f -e clone,fork ruby thread.rb) retorna bem mais coisas:

clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14588
Process 14588 attached
[pid 14588] clone(Process 14589 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14589
[pid 14588] clone(Process 14590 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14590
[pid 14589] +++ exited with 1 +++
[pid 14590] +++ exited with 0 +++
[pid 14588] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14589, si_status=1, si_utime=0, si_stime=0} +++
[pid 14588] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14588, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14591 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14591
[pid 14591] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14591, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14592 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14592
[pid 14592] clone(Process 14593 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14593
[pid 14593] +++ exited with 0 +++
[pid 14592] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14593, si_status=0, si_utime=0, si_stime=0} +++
[pid 14592] clone(Process 14594 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14594
[pid 14594] clone(Process 14595 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14595
[pid 14595] +++ exited with 1 +++
[pid 14594] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14595, si_status=1, si_utime=0, si_stime=0} +++
[pid 14594] +++ exited with 0 +++
[pid 14592] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14594, si_status=0, si_utime=0, si_stime=0} +++
[pid 14592] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14592, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14596 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14596
[pid 14596] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14596, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14597 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14597
[pid 14597] clone(Process 14598 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14598
[pid 14598] +++ exited with 0 +++
[pid 14597] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14598, si_status=0, si_utime=0, si_stime=0} +++
[pid 14597] clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14599
Process 14599 attached
[pid 14599] clone(Process 14600 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14600
[pid 14600] clone(Process 14601 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb4232139d0) = 14601
[pid 14601] clone(Process 14602 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb4232139d0) = 14602
[pid 14602] +++ exited with 0 +++
[pid 14601] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14602, si_status=0, si_utime=0, si_stime=0} +++
[pid 14601] +++ exited with 0 +++
[pid 14600] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14601, si_status=0, si_utime=0, si_stime=0} +++
[pid 14600] +++ exited with 0 +++
[pid 14599] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14600, si_status=0, si_utime=0, si_stime=0} +++
[pid 14599] +++ exited with 0 +++
[pid 14597] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14599, si_status=0, si_utime=0, si_stime=0} +++
[pid 14597] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14597, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14603 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14603
[pid 14603] clone(Process 14604 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb42e4469d0) = 14604
[pid 14604] +++ exited with 0 +++
[pid 14603] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14604, si_status=0, si_utime=0, si_stime=0} +++
[pid 14603] clone(Process 14605 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb42e4469d0) = 14605
[pid 14605] clone(Process 14606 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14606
[pid 14606] clone(Process 14607 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14607
[pid 14606] clone(Process 14608 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14608
[pid 14607] +++ exited with 1 +++
[pid 14608] +++ exited with 0 +++
[pid 14606] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14607, si_status=1, si_utime=0, si_stime=0} +++
[pid 14606] +++ exited with 0 +++
[pid 14605] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14606, si_status=0, si_utime=0, si_stime=0} +++
[pid 14605] +++ exited with 0 +++
[pid 14603] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14605, si_status=0, si_utime=0, si_stime=0} +++
[pid 14603] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14603, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14609 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14609
[pid 14609] clone(Process 14610 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14610
[pid 14610] clone(Process 14611 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14611
[pid 14610] clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14612
Process 14612 attached
[pid 14611] +++ exited with 1 +++
[pid 14612] +++ exited with 0 +++
[pid 14610] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14611, si_status=1, si_utime=0, si_stime=0} +++
[pid 14610] +++ exited with 0 +++
[pid 14609] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14610, si_status=0, si_utime=0, si_stime=0} +++
[pid 14609] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14609, si_status=0, si_utime=0, si_stime=0} +++
clone(child_stack=0x7fa6a3eedff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a3eee9d0, tls=0x7fa6a3eee700, child_tidptr=0x7fa6a3eee9d0) = 14613
Process 14613 attached
[pid 14587] clone(Process 14614 attached
child_stack=0x7fa6a27bdff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a27be9d0, tls=0x7fa6a27be700, child_tidptr=0x7fa6a27be9d0) = 14614
[pid 14587] clone(Process 14615 attached
child_stack=0x7fa6a25bbff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a25bc9d0, tls=0x7fa6a25bc700, child_tidptr=0x7fa6a25bc9d0) = 14615
[pid 14587] clone(Process 14616 attached
child_stack=0x7fa6a23b9ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a23ba9d0, tls=0x7fa6a23ba700, child_tidptr=0x7fa6a23ba9d0) = 14616
[pid 14587] clone(Process 14617 attached
child_stack=0x7fa6a21b7ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a21b89d0, tls=0x7fa6a21b8700, child_tidptr=0x7fa6a21b89d0) = 14617
[pid 14587] clone(Process 14618 attached
child_stack=0x7fa6a1fb5ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a1fb69d0, tls=0x7fa6a1fb6700, child_tidptr=0x7fa6a1fb69d0) = 14618
[pid 14614] +++ exited with 0 +++
[pid 14615] +++ exited with 0 +++
[pid 14616] +++ exited with 0 +++
[pid 14617] +++ exited with 0 +++
[pid 14618] +++ exited with 0 +++
[pid 14613] +++ exited with 0 +++
+++ exited with 0 +++
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14588
Process 14588 attached
[pid 14588] clone(Process 14589 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14589
[pid 14588] clone(Process 14590 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14590
[pid 14589] +++ exited with 1 +++
[pid 14590] +++ exited with 0 +++
[pid 14588] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14589, si_status=1, si_utime=0, si_stime=0} +++
[pid 14588] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14588, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14591 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14591
[pid 14591] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14591, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14592 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14592
[pid 14592] clone(Process 14593 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14593
[pid 14593] +++ exited with 0 +++
[pid 14592] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14593, si_status=0, si_utime=0, si_stime=0} +++
[pid 14592] clone(Process 14594 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14594
[pid 14594] clone(Process 14595 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14595
[pid 14595] +++ exited with 1 +++
[pid 14594] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14595, si_status=1, si_utime=0, si_stime=0} +++
[pid 14594] +++ exited with 0 +++
[pid 14592] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14594, si_status=0, si_utime=0, si_stime=0} +++
[pid 14592] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14592, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14596 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff2580cc9d0) = 14596
[pid 14596] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14596, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14597 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14597
[pid 14597] clone(Process 14598 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14598
[pid 14598] +++ exited with 0 +++
[pid 14597] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14598, si_status=0, si_utime=0, si_stime=0} +++
[pid 14597] clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14599
Process 14599 attached
[pid 14599] clone(Process 14600 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f1df327b9d0) = 14600
[pid 14600] clone(Process 14601 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb4232139d0) = 14601
[pid 14601] clone(Process 14602 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb4232139d0) = 14602
[pid 14602] +++ exited with 0 +++
[pid 14601] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14602, si_status=0, si_utime=0, si_stime=0} +++
[pid 14601] +++ exited with 0 +++
[pid 14600] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14601, si_status=0, si_utime=0, si_stime=0} +++
[pid 14600] +++ exited with 0 +++
[pid 14599] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14600, si_status=0, si_utime=0, si_stime=0} +++
[pid 14599] +++ exited with 0 +++
[pid 14597] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14599, si_status=0, si_utime=0, si_stime=0} +++
[pid 14597] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14597, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14603 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14603
[pid 14603] clone(Process 14604 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb42e4469d0) = 14604
[pid 14604] +++ exited with 0 +++
[pid 14603] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14604, si_status=0, si_utime=0, si_stime=0} +++
[pid 14603] clone(Process 14605 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb42e4469d0) = 14605
[pid 14605] clone(Process 14606 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14606
[pid 14606] clone(Process 14607 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14607
[pid 14606] clone(Process 14608 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fb27c11e9d0) = 14608
[pid 14607] +++ exited with 1 +++
[pid 14608] +++ exited with 0 +++
[pid 14606] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14607, si_status=1, si_utime=0, si_stime=0} +++
[pid 14606] +++ exited with 0 +++
[pid 14605] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14606, si_status=0, si_utime=0, si_stime=0} +++
[pid 14605] +++ exited with 0 +++
[pid 14603] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14605, si_status=0, si_utime=0, si_stime=0} +++
[pid 14603] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14603, si_status=0, si_utime=0, si_stime=0} +++
clone(Process 14609 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7fd34d4569d0) = 14609
[pid 14609] clone(Process 14610 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14610
[pid 14610] clone(Process 14611 attached
child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14611
[pid 14610] clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f2136e3e9d0) = 14612
Process 14612 attached
[pid 14611] +++ exited with 1 +++
[pid 14612] +++ exited with 0 +++
[pid 14610] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14611, si_status=1, si_utime=0, si_stime=0} +++
[pid 14610] +++ exited with 0 +++
[pid 14609] +++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14610, si_status=0, si_utime=0, si_stime=0} +++
[pid 14609] +++ exited with 0 +++
+++ SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=14609, si_status=0, si_utime=0, si_stime=0} +++
clone(child_stack=0x7fa6a3eedff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a3eee9d0, tls=0x7fa6a3eee700, child_tidptr=0x7fa6a3eee9d0) = 14613
Process 14613 attached
[pid 14587] clone(Process 14614 attached
child_stack=0x7fa6a27bdff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a27be9d0, tls=0x7fa6a27be700, child_tidptr=0x7fa6a27be9d0) = 14614
[pid 14587] clone(Process 14615 attached
child_stack=0x7fa6a25bbff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a25bc9d0, tls=0x7fa6a25bc700, child_tidptr=0x7fa6a25bc9d0) = 14615
[pid 14587] clone(Process 14616 attached
child_stack=0x7fa6a23b9ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a23ba9d0, tls=0x7fa6a23ba700, child_tidptr=0x7fa6a23ba9d0) = 14616
[pid 14587] clone(Process 14617 attached
child_stack=0x7fa6a21b7ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a21b89d0, tls=0x7fa6a21b8700, child_tidptr=0x7fa6a21b89d0) = 14617
[pid 14587] clone(Process 14618 attached
child_stack=0x7fa6a1fb5ff0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fa6a1fb69d0, tls=0x7fa6a1fb6700, child_tidptr=0x7fa6a1fb69d0) = 14618
[pid 14614] +++ exited with 0 +++
[pid 14615] +++ exited with 0 +++
[pid 14616] +++ exited with 0 +++
[pid 14617] +++ exited with 0 +++
[pid 14618] +++ exited with 0 +++
[pid 14613] +++ exited with 0 +++
+++ exited with 0 +++

Alí no final dá para ver as 5 threads que eu pedi no script sendo abertas no SO. Inclusive, se analizar todo esse retorno aí dá para ver que o Ruby criou 6 threads, uma delas o ruby cria mesmo se vc fizer só um puts num script. :)

Discutir sobre linguagens com os amigos sempre é legal para pesquisar e descobrir coisas novas. :)

Golang and 1.2 version performance improvement

Unknown — Tue, 03 Dec 2013 00:00:00 +0000

I've started using Go last month and I really liked to work with the language.

The project I'm working on is dead simple and just retrieves metrics and save on a redis server (the data will be analyzed by a different project that I'm working on). So I have 15 goroutines retrieving data constantly and I'm using just two native threads.

I did some CPU profiling on the code using my current machine for Golang 1.1.2 and 1.2 and the results can be seen below.

Golang 1.1.2:

    (pprof) top10
    Total: 188701 samples
    137454  72.8%   72.8%   137454  72.8% crypto/des.permuteBlock
    44032   23.3%   96.2%   169187  89.7% crypto/des.feistel
    3750    2.0%    98.2%   184544  97.8% crypto/des.cryptBlock
    823     0.4%    98.6%   185650  98.4% crypto/cipher.(*cbcDecrypter).CryptBlocks
    290     0.2%    98.8%      290   0.2% encoding/binary.bigEndian.PutUint64
    232     0.1%    98.9%      232   0.1% encoding/binary.bigEndian.Uint64
    227     0.1%    99.0%      227   0.1% crypto/sha1.block
    215     0.1%    99.1%      267   0.1% encoding/json.state1
    207     0.1%    99.2%      430   0.2% encoding/json.checkValid
    178     0.1%    99.3%      398   0.2% encoding/json.nextValue

    # top command result
    PID USER      PR  NI  VIRT    RES      SHR S  %CPU %MEM    TIME+  COMMAND
    18115 pothix    20   0  871800  67888   3932 S 188.8  1.7  12:40.08 crebain

    # A snapshot of the processors
    %Cpu0  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    %Cpu1  : 95.0 us,  3.0 sy,  0.0 ni,  2.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

Golang 1.2:

    (pprof) top10
    Total: 6894 samples
    1686    24.5%   24.5%   1686    24.5%   crypto/aes.decryptBlockGo
    1299    18.8%   43.3%   3093    44.9%   crypto/cipher.(*cbcDecrypter).CryptBlocks
    471     6.8%    50.1%   1062    15.4%   encoding/json.checkValid
    420     6.1%    56.2%   541     7.8%    encoding/json.state1
    359     5.2%    61.4%   359     5.2%    crypto/sha1.block
    305     4.4%    65.9%   838     12.2%   encoding/json.nextValue
    245     3.6%    69.4%   274     4.0%    syscall.Syscall
    230     3.3%    72.7%   230     3.3%    encoding/json.stateBeginValue
    186     2.7%    75.4%   225     3.3%    encoding/json.stateEndValue
    156     2.3%    77.7%   156     2.3%    runtime.memmove

    top command result
    PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
    20534 pothix    20   0  598428  51584   3532 S  12.9  1.3   0:03.76 crebain

    %Cpu0  : 12.1 us,  5.1 sy,  5.1 ni, 72.7 id,  5.1 wa,  0.0 hi,  0.0 si,  0.0 st
    %Cpu1  : 20.0 us,  4.0 sy,  0.0 ni, 75.0 id,  1.0 wa,  0.0 hi,  0.0 si,  0.0 st

What an improvement! :)

I know that this application may not be the best example to compare Go with a different language because it depends of a third application (that is my bottleneck BTW) and Ruby perform as good as the new version but I really liked to give Go a try.

Go language has a lot of interesting ideas and it is growing fast. Looks like it is a good idea of language for some of my projects, welcome Golang!

Plaev, HTML5 e Skeleton-jigsaw

Unknown — Tue, 04 Dec 2012 00:00:00 +0000

Depois de muito tempo desenvolvendo finalmente terminamos o Skeleton-Jigsaw em outubro! Demorei para postar sobre isso aqui no blog por falta de tempo, mas aqui está!

Eu e o Rafael Masoni trabalhamos nesse jogo durante quase 1 ano (começamos a falar dele no comecinho de janeiro) investindo nosso tempo livre para fazer todas as partes do jogo (audio, programação, arte, game design, level design e etc).

Vou descrever um pouco do que fizemos e como organizamos, mas vai ser apenas um resumo do que falamos na nossa palestra no Guru-SP:

Obrigado pelo vídeo Agaelebe!

Começamos a trabalhar em janeiro do ano passado no que seria um protótipo da impact e aos poucos o jogo foi tomando forma e estavamos investindo cada vez mais esforço nele. A cada semana fazíamos uma Skype call para discutir no que trabalharíamos durante a semana e fazíamos o possível para entregar o que conversamos até a próxima call.

Foi bem legal trabalhar em todos os pontos do jogo, opinando em arte, trabalhando em trilha sonora, programando, discutindo level design, escrevendo uma prévia de história, otimizando assets, testando em vários navegadores, fazendo game design e tudo mais.

Todo esse trabalho trouxe muitas experiências legais de como é entregar um jogo funcional e completo para o seu escopo, e estou bem orgulhoso de conseguir entregar o jogo demo finalizado, e não deixar mais um trabalho incompleto perdido por aí.

Ainda não sabemos quais os planos para a Plæv, mas agora ela já tem seu primeiro jogo demo para não ficar com o portfolio em branco. :)

Não quis descrever muito aqui no post para não ficar somente repetindo conteúdo do vídeo, mas se tiverem dúvidas coloquem nos comentários.

Javascript and Gamedev discussion

Unknown — Sun, 02 Sep 2012 00:00:00 +0000

I read the blog post from Impact engine creator Dominic where he shows an email he sent to John Carmack about his opinions on Javascript expressed on his keynote.

Dominic is trying to show that Javascript is not a good language to develop the next AAA game but it is awesome to make simple games and have it easily available to the world.

We have a lot of negative comments on the post (I really don't know why) but some good ones too. One of the good comments was written by John Carmack himself!

He was just explaining his point of view about Javascript and game development, and said what we already know and is obvious (right?) that javascript is not so fast to perform some kind of tasks.

Some people are dreaming that Javascript is so fast as C in some cases but we know that it is not true for a whole game and the native version will always run faster. But you should say that the web (and the computers at all) are evolving each day, so the javascript performance, but the native version is evolving as well and javascript will always be some steps back.

John's comment is really interesting because he knows that javascript has its benefits but he also knows that some of the real problems they are solving at Id Software will not be solved efficiently using Javascript (and a browser) as the platform.

The conclusion for the discussion is what I was expecting:

"Choose the right tool for the right job"

Are you doing a little 2D game? Try javascript, and define the platforms for it to run. But if your game really needs performance because you need to have the most impressive graphics, you need to go native.

Obviously you should choose a lot of different languages / platforms as well, you just need to decide which one is better for your business.

Use the right tool. That's it, no silver bullet. :)

Kernel compiling

Unknown — Mon, 23 Jul 2012 00:00:00 +0000

Since I bought an Acer notebook to use Linux again (I sold my mac, I have a post about it but in portuguese) I started to compile my own kernel.

The reasons for the decision:

I have a hardware that works better with the newer kernels. I really want to understand the linux kernel better. As Judas Priest sings on Painkiller song: “I’m living on the eeeeeedge”. LOL

How to proceed

There are some steps to follow when compiling a new kernel for your Linux box:

Clone the kernel repository with git, I made it using the Github url:

git clone git://github.com/torvalds/linux.git

Copy your .config file to the linux folder. If your distro have the "Enable config.gz" flag enabled (most distros have it) you can use the generated config as a base for your new compiled version:

zcat /proc/config.gz > linux/.config

Now that you have a functional config file (it was running on the stock kernel right? ), just cd do the kernel folder and run make:

cd linux
make

This process take about 40 minutes to finish on my i7, with 4GB of RAM and SSD, running with -j4, to use all the 4 cores. Obviously the time to finish will depend on what it will need to compile (defined on the .config file) and the processing power of your machine. You can improve this compiling time but I’ll talk more about it later.

You can use the compiling time to prepare the mkinitcpio file for the installation. On my archlinux box I have created a file named git.preset on /etc/mkinitcpio.d/ directory with the following content:

ALL_config="/etc/mkinitcpio.conf"
ALL_kver="/boot/vmlinuz-git"

PRESETS=('default')

default_image="/boot/initramfs-git.img"

After that you’ll need to change your bootloader conf a bit. I’m using grub (not grub2 yet) which makes the setup really easy! Just change your /boot/grub/menu.lst and add something like this:

title  Git Kernel
root   (hd0,0)
kernel /vmlinuz-git root=/dev/sda2 ro quiet acpi_backlight=vendor init=/bin/systemd
initrd /initramfs-git.img

PS: I’m using systemd to init and I need to define the acpi_backlight to make my hardware to work properly, but probably you’ll not need these parameters. If you’re using grub, you may find useful to copy the other configuration of the same file and change what needs to me changed (title and initrd).

When the compilation ends and your mkinitcpio file is ready you can continue the process by generating the modules for your kernel:

sudo make modules_install

This command will create a folder with the compiled modules on /lib/modules. After that, just copy the generated image file to the boot directory:

sudo cp arch/x86_64/boot/bzImage /boot/vmlinuz-git

And create the initial randisk environment for your preset using mkinitcpio:

sudo mkinitcpio -p git

DONE! Your kernel is compiled and ready to boot! Just restart you computer and choose the new item on the boot menu!

.config tunning

So, your new kernel is running perfectly (I hope so…It’s a release candidate, we never know what may happen :P), but you’ll want to go deeply into the kernel options and improve the compiling time and the disk space for the kernel, so lets tune the .config file to be specific to our hardware!

WARNING: It will take a lot of time to get a good configuration and you’ll not receive so much benefit from it, but it will be fun. I promise.

So, let’s get started! Go to the linux kernel directory and run:

make menuconfig

The fun part starts here because you’ll be seeing an awesome curses screen with a lot of menus and submenus about a lot of things that you never heard about, but no despair! Some things you already know, like your processor for example! If you have an Intel processor is safe to remove all the AMD related configurations from the .config file and probably add some intel ones as built in (and vice versa).

Some things you need to have in mind when starting to buil your own kernel configuration is that you really need to know what hardware you’re running on your machine. This is really interesting because we don’t care so much about some pieces of hardware nowadays, and you’ll need to care about it if you want to build your own configuration because you can’t remove these modules.

A good way to start is boot with the stock configuration, run lsmod and backup this into a file. These modules should not be removed because they are making your machine to work as it is working now, but some of them should be marked as builtin into the kernel. I saw some recommendations to not include the WIFI driver as builtin to avoid some pre-load problems, so I’m keeping my WIFI driver as a module.

Some cool (but not so useful) parts can be found on “General Setup”:

Default hostname – This configuration will be specific, so name your machine! Local version – Append an string to the kernel release I can’t help you so much on this journey because each hardware has its own dependencies and corner cases, so you will need to compile and see how it’s going to fit your needs.

Some tips

If you’re planning to customize your configuration file I really recommend to use a versioning control (like git) to keep tracking of your file because you’ll need to revert some changes sometimes (believe me) and git will help you to make this process less painful.

Conclusion

We are weird people (me for writting this and you to be interesting in doing the same thing) but this process will help you to understand some interesting things about your operating system and feel that there is no magic happening there, this is just code that you can change if you want. I was planning to end this article with “there is no advantage on making this at all” but after remembering all the process I think that I learned a lot, so it is worth it.

Menos mac e mais Linux

Unknown — Thu, 19 Jul 2012 00:00:00 +0000

TL; DR Usei mac por mais de 6 meses e decidi voltar ao Linux. Na minha opinião mac não é ruim, mas Linux é melhor.

A idéia desse post não é fazer um flame war, muito menos justificar porque eu voltei para o Linux (afinal, eu não devo nada pra ninguém), e sim falar um pouco do que eu vi de vantagens e desvantagens no Mac e porque eu resolvi voltar a usar Linux.

Bem, como muitos sabem eu comprei um Mac no meio do ano passado, era um Macbook pro de 13 polegadas, i7, 4GB de RAM e etc. Como eu imaginava, era uma maquina boa e estável para trabalhar, fazer minhas pesquisas e levar na mochila (era muito mais leve e compacto que meu antigo Toshiba Satellite).

Antes de usar Mac eu estava usando o Toshiba Satellite que eu mencionei acima usando Ubuntu como sistema operacional, e tudo estava indo bem sem contar o peso que era levar o computador para a faculdade sempre.

Enfim, um colega foi para um evento fora do país e eu pedi para que comprasse um Macbook pro para mim, e assim foi feito, estava com um Mac. Refiz tudo que tinha do Linux para utilizar no estilo Mac, ou seja: Formatei todo o meu HD para usar o formato do Mac, comecei a utilizar time machine, alterei uma boa parte dos meus config files para aceitar Mac também e etc.

E lá começa meu uso do Mac, comecei a instalar as ferramentas que eu estava utilizando na época. Primeiro começando com as ferramentas de desenvolvimento, peguei um Xcode com um colega para não precisar baixar e a única coisa que ele fez foi bugar e não deixar nem instalar nem desinstalar (sim, procurei na internet tinham algumas soluções que supostamente resolviam mas não resolveram).... Enfim, foi a primeira coisa que eu instalalei, então foi só instalar o sistema denovo e boa! Baixei o Xcode (mais de 1GB!!!!1!!!um!!), para poder compilar tudo que eu precisava e tudo estava indo bem, só não parecia muito natural algumas coisas para quem está acostumado a usar Linux, mas tava indo bem.

Nessa época eu estava terminando o meu TCC, que eu estava escrevendo com LaTeX, portanto fui instalar um pacote do LaTeX no Mac, e lá se vão mais 1GB de pacotes... Tudo bem, instalei e funcionou beleza.

Como já tinham dito, foi meio chatinho configurar o MySql mas funcionou de boas. O homebrew ajuda bastante na tarefa de instalar coisas, é um slackbuilds do futuro, tem várias receitas para resolver os casos de coisas que precisam ser instaladas, e funciona bem.

Depois do ambiente todo feito o uso era bem tranquilo, e eu sentia que era bem confortável para usar em coisas que não eram diretamente ligadas com programação. Assistir minhas séries era bem legal, tinha alguns softwares que facilitavam acompanhar algumas séries (TvShowsApp) e até baixar as legendas automaticamente (Subsmarine), o que era bem comodo.

Eu tenho trabalhado bastante com HTML5 ultimamente portanto eu mantinha umas 5 versões de navegadores na maquina, e no Mac isso foi bem simples de fazer, apenas arrastando os navegadores para a pasta de Apps e já era.

A resolução do Mac no meu monitor externo era fantástica comparada com a que eu tinha antes no Toshiba, apesar de eu não usar muito o monitor externo. O som e vídeo funcionam muito bem, como era de se esperar e apresentações, skype calls e outras coisas eram bem simples e naturais de se fazer.

Algumas das aplicações que eu usava no Linux estavam disponíveis no Mac, como o Vim por exemplo, que apesar de ter que instalar o Macvim ele ficava disponível no terminal também. Tive que fazer algumas modificações para que o Vim funcionasse como eu esperava, mas no fim das contas ele estava funcionando normalmente. O GIMP no Mac é bem ruim, e deixa bastante a desejar, até porque ele sobe o X para poder ser executado e foge completamente do padrão do Mac, o que já era esperado, afinal não portaram o GIMP para rodar, apenas emularam o X e rodaram sobre a plataforma do mac (não é só isso, mas o que eu quis dizer é que não é um GIMP feito para mac específicamente, só fizeram ele rodar lá), e isso é bem triste.

O tempo passou e eu tive a oportunidade de ir para San Francisco no OpenStack Summit, e eu pensei em trocar de computador, e por coincidência um colega estava perguntando se alguem estava vendendo um Macbook de 13" (!!), não perdi tempo, negociei e vendi por um preço muito bom (tendo em vista que comprei fora do país e vendi por aqui). E comecei a consultar valores de outros computadores para a substituição. Durante essa coleta de preços eu até cheguei a cogitar comprar o Macbook Air, mas eu estava certo de que mac para mim já deu o que tinha que dar, e agora era hora de voltar ao bom e velho Linux.

No fim das contas eu comprei o computador que possuía o melhor custo X benefício para o que eu precisava, que é o Acer S3-951-6432, que possui tela de 13", SSD de 256, 4GB de memória, processador i7, leitor de cartão da Realtek, placa wireless Atheros e uma placa de vídeo intel 3000.

Dessa vez eu queria usar Linux de verdade, conhecendo tudo o que eu estava utilizando no sistema, portanto resolvi começar a usar Arch Linux, e comecei a saga de instalar cada pacote, desde o sudo, passando pelo ifconfig, X, Awesome e por aí vai. A princípio decidi ficar sem Gnome e configurar o Awesome para funcionar como eu queria, mas no fim das contas eu acabei resolvendo instalar Gnome para facilitar as coisas de vez em quando.

Com o Arch Linux eu consigo ter controle de tudo que está rodando e fico sempre no bleeding edge de quase todos os softwares devido a filosofia de rolling updates dele. Aproveitei também para começar a compilar meu próprio kernel, removendo módulos desnecessários e adicionando outros que são necessários para meu hardware como builtin.

Não precisei ficar me preocupando com as ferramentas de desenvolvimento, tudo estava fácil de arrumar, e não tive problema algum, foi só instalar o gcc e mandar bala! Para o LaTeX, foi só instalar alguns poucos megas de TexLive e tudo estava funcionando. Pude voltar a usar o bom e velho GIMP, juntamente com o Inkscape e tudo parecia mais feliz.

Alguns podiam comentar que eu poderia ter usado o Photoshop no Mac, mas eu to de boas de pirataria, e o GIMP resolve todos os meus problemas...Não quero ficar gastando dinheiro com software que não seja realmente necessário.

Conclusão

O Mac não é um sistema ruim, é funcional e bem estável. O que eu constatei com isso tudo é que o Mac apenas não é um Sistema operacional para mim, eu gosto mesmo é de usar software livre, contribuir, customizar, conhecer coisas novas, tentar tunar meu hardware para funcionar melhor, usar Window manager esquisito, compilar o kernel e etc.

Outra barreira que caiu foi o Mac nunca travar, ele travou como qualquer outro SO que eu já usei, além de ser um SO muito mais lento do que eu esperava. Muitas pessoas me disseram que isso era coisa do Lion ou que era porque eu tinha só 4 GB de RAM, mas nenhum dos dois argumentos são válidos para mim, se o Lion é uma bosta o problema não é meu, é só mais um motivo para eu parar de usar porcarias, e se eu preciso de 8GB de RAM para poder ficar com um notebook usável, eu prefiro mil vezes usar Linux com 4 GB e ser feliz.

A minha opinião final foi que é totalmente possível trabalhar no Mac e programar todas as coisas que se programa no Linux, a diferença é que no Linux é tudo mais natural de fazer mas nada que compilar no mac ou usar o slackbuilds...digo....homebrew... para fazer isso não resolva, portanto ele ficou no mesmo patamar do Linux, cada um com suas vantagens e desvantagens, e as vantagens do Linux me atraem mais do que as do Mac.

Ah, e não me venha com historinha que "O legal do Mac é a experiencia". :P

Aprendendo com o código do Quake

Unknown — Wed, 18 Jul 2012 00:00:00 +0000

Desde que eu terminei a faculdade eu venho lendo bastante coisa útil (foi muita coisa inútil durante 4 anos...) e aprendendo bastante coisa. Nos ultimos meses eu li vários code reviews dos códigos do Quake e do Doom.

Os review foram feitos por Fabien Anglard e estão todos disponíveis no site dele http://fabiensanglard.net.

O primeiro artigo que eu li foi sobre o code review do código do Quake 2 de 1997. Esse quake foi o ultimo que fez Software Rendering e o cara que analizou o código explica direitinho como foi feito, explicando todos os problemas que os desenvolvedores enfrentaram e porque eles chegaram aquela implementação. Para quem é programador e curte Quake é uma ótima leitura.

Uma coisa muito interessante que vi na leitura desse artigo foi que eu acabei estudando várias outras coisas para poder entender o artigo, como:

BSP trees: http://downloads.gamedev.net/pdf/gpbb/gpbb59.pdf
Octree: http://en.wikipedia.org/wiki/Octree
Memory management: http://www.ualberta.ca/CNS/RESEARCH/LinuxClusters/mem.html
Radiosity: http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm (esse artigo é animal)

E outras coisas do mesmo genero.

Com o lançamento do código do DOOM 3 open source, mais um code review foi escrito: http://fabiensanglard.net/doom3/, e nesse review ele explica como a parte de iluminação (que era a grande funcionalidade do Doom 3) foi feita e quais as técnicas foram utilizadas. Apesar de eu conhecer pouco de renderização e algoritmos de iluminação é possível entender uma boa parte desse review.

E por ultimo li o code review do código do Quake III, que mostra uma das coisas que eu estava curioso para ler, networking! Todos sabemos que a parte de redes (não somente ela, acho que tudo) precisa de velocidade, e eu queria entender o que os caras planejaram para essa camada, e isso é uma das coisas que o code review traz, inclusive linkando para a análise da antiga engine do Quake e explicando algumas decisões e as premissas simples que foram utilizadas para construir uma camada consistente e deixar o jogo o mais fluido possível.

Esse ultimo code review acaba muito legal, linkando para a IA do Quake III, que é muito boa por sinal, e por isso rendeu uma tese de mestrado do desenvolvedor que apesar de eu não ter lido inteira, eu recomendo a leitura para quem se interessa no assunto.

Enfim, todos sabem que o John Carmack é um dos programadores que eu mais admiro, e Quake é um dos jogos que eu mais curto, e o código é open source! Esse review era a oportunidade que faltava para conhecer o código melhor e aprender coisas novas. Se você curte jogos e programação RECOMENDO fortemente tirar algumas horas e ler os reviews!

Palestra sobre implementacoes paralelas

Unknown — Mon, 16 Jul 2012 00:00:00 +0000

Esse post ficou como draft desde que eu palestrei sobre implementações paralelas, e agora que eu lembrei dele decidi publicar! :)

Bem, como eu disse, eu paletrei sobre implementacoes paralelas tanto na Locaweb como no Guru-SP. A idea da palestra vem de um post do John Carmack sobre implementações paralelas, e nesse post ele comenta sobre todos os tipos de implementação paralela que ele já utilizou e as que mais funcionaram para cada tipo de caso.

Na minha palestra eu comento sobre todos os tipos de implementacoes que eu ja utilizei e quais delas foram boas ou ruins para determinado caso.

Essas técnicas simples ajudaram a manter nosso código muito mais fácil de manter. Espero que seja útil para mais alguém. ;)

XMPP e Ruby

Unknown — Tue, 10 Jul 2012 00:00:00 +0000

Alguns (vários…) meses atrás eu fiz uma palestra pequena no Guru-SP(São Paulo Ruby Users Group) sobre Ruby e XMPP, os vídeos e slides estão disponíveis:

Nessa talk eu mostrei como criar dois bots simples e como subir eles na sua conta do Gmail. A Gem blather tem uma DSL bem legal para trabalhar com XMPP em Ruby, mas nos meus testes funcionou muito melhor com ruby 1.9.3 do que com 1.9.2.

Para fazer a parte de daemon e gerar uma estrutura para o projeto eu utilizei uma gem chamada daemon-tools, que provê vários metodos úteis para esse tipo de projeto.

Se tiverem dúvidas postem aí nos comentários.

Sempre aprender coisas diferentes

Unknown — Wed, 27 Apr 2011 00:00:00 +0000

Estou começando a fazer meu TCC agora e resolvi brincar um pouco com LaTeX. Ja faz um bom tempo que eu queria brincar um pouco com ele, entender melhor como funciona e por que tanta gente usa ele e acha legal.

Eu tive um pouco de experiência com LaTeX quando estava ajudando a escrever o vimbook, mas não tive contato o suficiente por que entrei no meio do projeto e já estava tudo pronto, foi só seguir a estrutura.

O que eu achei interessante nisso tudo foi um dos comentários que eu ouvi: "Por que você não usa o Word, é bem mais fácil". Eu não discordo que provavelmente é mais fácil no Word, apesar de você perder o log de alterações, não ter o arquivo distribuído automáticamente (como eu to fazendo com o Git) e outras coisas. Quem me conhece sabe que nem de Windows eu gosto, mas eu poderia usar OpenOffice e um template e tal.

O mais interessante nisso tudo é conhecer várias coisas, saber o que é bom e ruim ao invés de ficar coletando informações de algumas pessoas (que as vezes nem utilizaram para dar opinião) e utilizar isso como "conhecimento" da tecnologia.

Se você resolve perguntar para uma pessoa dessas se ela conhece textile, markdown, LaTeX ou qualquer coisa do genero, ele vai responder que não, ou seja, o maledeto só conhece o Word e considera isso a melhor ferramenta do mundo, não tem nem como argumentar sobre mais nada por que nunca usou.

Enfim, esse foi apenas um caso besta que aconteceu comigo, mas isso acontece com muita coisa, como programação por exemplo! Pessoas que só usam Java, ou só usam Python, ou só usam Ruby, ou qualquer outra, e vem falar da outra linguagem apenas se baseando no que ouviu falar, sem nem mesmo ter usado para sentir os problemas e as vantagens da linguagem.

E mais uma vez, esse foi só mais um exemplo, isso acontece muito ultimamente, pessoas que simplesmente querem "dar sua opinião" sobre uma coisa, independente se conhecem ou não essa coisa.

Se quer mesmo dar sua opinião, tenha pelo menos algum conhecimento prático (mesmo que seja básico) sobre o assunto, ou então STFU. :)

Organizando os Feeds do Blog

Unknown — Mon, 24 Jan 2011 00:00:00 +0000

Como muitos sabem, eu sou meio doido por organização (heheh) e eu mesmo não gosto de ficar lendo coisas que não me interessam de outros blogs, ou seja, no blog de alguém que gosta bastante de Vim eu ter que ficar lendo sobre paraquedismo :P

Agora eu gostaria de além de escrever sobre coisas técnicas, escrever também sobre os meus outros hobbies, como Motos, Shows e etc. Alguns deles eu até já escrevia um pouco antes, mas nem tanto, e isso já me incomodava um pouco, por que eu sei bem que várias pessoas que seguem o feed não gostam das mesmas coisas que eu.

Então minha idéia foi simples, criei um feed só para os posts técnicos (programação, Vim, eventos de tech, e coisas relacionadas), e o que eu achar que não é tech eu não coloco a tag.

Portanto, se você só quer ver os posts técnicos do meu blog, assine este feed, e o feed atual começa a ser o "FULL" onde terá todos os posts. :)

Se você não liga para só ler posts técnicos e quer ler tudo que eu colocar, é só ignorar isso tudo :)

Meu ambiente de desenvolvimento

Unknown — Wed, 29 Dec 2010 00:00:00 +0000

Fui convidado pelo @jtadeulopes e pelo @qmx para participar do meme sobre ambientes de desenvolvimento, então estou fazendo esse post para falar um pouco mais sobre o meu.

Sistema Operacional

Já usei Windows um bom tempo atrás, e agora tenho um pós-conceito para usar (preconceito é só quando vc não conhece), não vejo nenhuma vantagem para utilizar ele e acho que não vale o preço (tenho um Vista e um Win7 originais que ganhei na compra do notebook e na CampusParty e nem uso).

Já usei Slackware (e ainda tenho ele instalado no meu notebook para brincar de vez em quando) e atualmente estou utilizando só o Ubuntu, que me fornece um ótimo ambiente para desenvolvimento. Acho muito fácil instalar coisas novas para dev com o Ubuntu, e tudo se encaixa muito bem com esse SO.

Controles de Versão

Já utilizei um pouco de SVN, Mercurial e Bazaar, mas não o suficiente para falar bem ou mal de qualquer um deles, por que quando eu utilizei eles supriram a minha necessidade tão bem quanto o Git. Atualmente utilizo muito o Git, que eu acho fantástico, e a cada hora que vou utilizando eu descubro coisas novas que me surpreeendem. Não utilizo nada gráfico para o Git, apenas linha de comando, afinal, do que mais eu preciso!? :D

Linguagens de Programação

Gosto de brincar com várias linguagens e sempre estou mexendo um pouco com Python e Javascript. Já faz um tempo que eu não brinco com C++, mas é outra linguagem que eu gosto bastante também.

Algum tempo atrás brinquei um pouco com desenvolvimento de aplicações para Android e para isso tive que brincar um pouco com Java também :). Mas como todos sabem, a linguagem de programação que eu mais uso atualmente é Ruby, que uso no trabalho e para alguns projetinhos pessoais.

Editor de texto / IDE

Eu uso o único editor de texto que uma pessoa em plena sanidade poderia usar, ou seja, o VIM! heheheh :D

Saindo da trollagem e voltando as vantagens, eu gosto do Vim por que ele é um editor rápido, customizável, e me faz pensar a todo momento. Para mim é estar resolvendo puzzles a cada minuto, acho divertido ficar pensando em como eu poderia estar editando aquele texto de uma forma mais divertida, e consequentemente, quanto mais eu aprendo a editar textos de uma maneira melhor mais rápido eu vou ficando para editá-los.

Claro que não é viável utilizar o Vim para tudo (apesar de eu estar escrevendo esse post por ele...heheh), e para algumas coisas é mais viável utilizar uma IDE. Para desenvolvimento de apps para o Android por exemplo, é muito mais fácil desenvolver utilizando o Eclipse que já tem plugin que ajuda em algumas tarefas, e é Java...Não preciso dizer mais nada.

Musica

Sempre estou com meu player aberto ouvindo musica, e sempre estou ouvindo coisas diferentes, começo com um random na minha lib inteira e escolho uma banda nesse meio para ouvir. Eu tenho uma playlist das musicas que eu mais curto para ouvir nos dias que não estou afim de ficar ouvindo coisas aleatórias. Já testei diversos players no Linux (banshee, amarok e etc), e atualmente estou utilizando o Rhythmbox, que reconhece meu Ipod e posso ouvir sempre a mesma lib em casa e no trabalho.

Se quiser saber as musicas que eu ouço veja meu last.fm.

IMs

Geralmente fico logado em mais de 6 contas de IM (2 Gtalks pessoais, 1 Jabber da empresa, 2 contas de IRC, 1 conta de Skype e ainda tem o softphone). Parece ser meio bizarro ficar logado em tudo isso todo o tempo, mas eu só consigo essa proeza por que as pessoas que eu tenho nos IMs são inteligentes o suficiente para olhar o meu status e não em encher quando não devem, caso não eu não possa falar apenas aviso e pronto. Em casos que preciso de bastante concentração eu fecho quase todos, deixando apenas uma conta que tem só algumas pessoas adicionadas :)

Só para constar, se você usa MSN isso não funciona, por que se a pessoa usa MSN ela já não tem nenhuma noção.

Terminal

Aqui é onde eu passo 90% do meu tempo de trabalho, utilizando linha de comando, Vim (não uso interface gráfica para ele também...Não faz sentido para mim), Git e scripts em geral. Atualmente eu uso o gnome-terminal do Ubuntu, que não deixa a desejar. :)

Organização

Eu sou meio bizarro quanto a organização, e no meu ambiente tudo tem que ficar em seu devido lugar, assim, cada atalho de teclado me leva onde eu sei que as coisas estão. No trabalho tenho 2 monitores e 4 areas de trabalho, sendo que fica organizado assim:

Um browser em cada monitor

Firefox com Vimperator na esquerda com 3 abas com páginas que eu uso no sistema que eu trabalho atualmente
Chrome no monitor da esquerda com 2 e-mails, todoist e pivotal tracker

Todos os IMs e um terminal
Dois terminais, um em cada monitor com projetos auxiliares
Dois terminais, os dois abertos com o projeto que estou trabalhando

No terminal da direita deixo uma aba com Rails server, uma com Rails console e uma para o Vim
No terminal da esquerda rodo testes e outras coisas

Tem várias outras coisas que uso (como o Notecase para tomar notas por exemplo) mas acho que isso ae já é uma visão geral :D

Agora eu passo a bola para o @dlibanori, @crocidb e @sceadugenga

Semana de eventos (#rubyconfbr, #adl e #gddbr)

Unknown — Sun, 31 Oct 2010 00:00:00 +0000

Na semana passada (semana do dia 24 ao dia 30 de outubro) foi uma semana de grandes eventos, que eu tive o prazer de participar de todos! :)

Rubyconf Brasil

A Rubyconf Brasil é o Antigo Rails Summit Latin America, que acontecia no centro de convenções do Anhembi, e agora mudou sua localização para o centro de convenções Frei Caneca, para diminuir os custos e prover um local mais acessível para os participantes (próximo ao metrô e a avenida paulista).

O evento foi muito bom, contando com mais de 20 palestras com um número bem equilibrado de palestrantes nacionais e internacionais, que ministraram muitas palestras com ótimo conteúdo técnico. Infelizmente o evento teve problemas com WIFI, e os participantes mal conseguiram acessar a internet utilizando a infra do evento.

Algumas palestras:

A palestra do Jim Weiric sobre SOLID Ruby foi fantástica! Além dele ser um ótimo orador, muito divertido, mostrou conceitos bem interessante e algumas comparações com outras linguagens. Uma das melhores palestras do evento.
O tenderlove mandou muito bem na sua palestra sobre Fibers e ruby 1.9. Além das corriqueiras brincadeiras com fotos sobre a suposta criação da palestra, ele mostrou um conteúdo muito interessante, com muitos exemplos préviamente contruídos para demonstrar o conceito de Fibers. Uma palestra densa mas muito boa! :)
O José Valim palestrou sobre Rails 3 e mostrou algumas das novas funcionalidades e também o que estar por vir, e como sempre deixou a dica para a galera contribuir, "as próximas features depende de vocês" :)
O Yehuda Katz fez uma palestra bem interessante sobre como melhorar a performance da sua aplicação movendo muito de sua lógica para o cliente, e apresentou um projeto que ele está trabalhando atualmente. Gostei do conceito, mesmo pensando que não é um conceito para aplicar para qualquer aplicação web, mas para um aplicação com muitos acessos faz muitos sentido e o modelo parece bom. :)
O pessoal da Caelum Anderson Leite e Guilherme Silveira apresentaram sobre como utilizar uma Ruby funcionalmente, e a palestra foi muito boa, apesar de ser bem densa e os dois falarem rápido

Tiveram outras ótimas palestras, sobre encoding do Ruby (que é bizarro assim como qualquer outra implementação de encoding), integração de redes sociais, redis e resque e etc. Não vou falar de todas aqui para o post não ficar muito grande, mas aconselho a ficar de olho nas notícias pois a Locaweb filmou o evento e provavelmente vão liberar os vídeos das palestras, e quando isso acontecer, aconselho você a assistir! :)

E é claro que nesse evento também teve um espaço para a desconferência, onde apareceram algumas outras apresentações legais (cômicas ou não), sobre assuntos derivados, como: node.js, deploy continuo, programando algo parecido com Ruby para Java, e etc! Foi bem divertido também!

Além de tudo isso ainda temos que contar o networking com a galera que foi fantástico, rever velhos amigos que quase nunca vemos (a galera da Fande e do Ikwa (@mateuslinhares, @danielaltman, @jorge_silveira, @willian, @_bojak, @rafaeltimbo e @vitormateus) por exemplo), reencontrar o pessoal do Guru-SP que apesar de encontrar sempre é legal reunir toda a galera e foi mais um encontro :), e ainda tem mais um monte de gente que encontrei por lá, e isso fora as pessoas que conheci! Enfim...Networking #FTW! :).

Minhas fotos do evento

Android Dev Lab

Eu sinceramente esperava que o Google fosse dar um Nexus One para a galera assim como eles fizeram na OSCon lá fora, mas obviamente me enganei :P. No fim das contas o evento foi razoável, apesar dos problemas com WIFI (que já é corriqueiro...), foi interessante para conhecer um pouco do SDK, principalmente para quem não ia no Google Developers Day no dia seguinte (o que não foi o meu caso), e para ganhar uma camiseta bonitinha do Android :P

Resumo: Foi legal mas eu esperava mais.

Minhas fotos do evento

Google Developers Day

Para compensar o Android Dev Lab o GDD foi um evento fantástico! Muito mais gente (como era de se esperar) poucos lugares nas palestras principais, mas um ótimo conteúdo de palestras (se você souber escolher bem :D).

Algumas palestras:

Para mim foi quase um Tim Bray Developers Day, por que eu assisti 3 palestras do Tim Bray, todas sobre Android, direta ou indiretamente. Gostei de todas, o Tim falou muito bem sobre os temas que escolheu. Deu uma boa visão sobre design de aplicações, sobre o Android em si (algumas coisas eu já tinha visto no dia anterior...), e mostrou por que eles seguem algumas filosofias.
Uma frase que ele falou que eu ia mencionar no twitter na hora mas não ia caber, e resolvi deixar para (trollar aqui n)o post:
"O Android Market não precisa de moderação por que sabemos que as pessoas são inteligentes e caso uma aplicação não seja boa ou pareça maliciosa, eles simplesmente não instalam e não usam"
A palestra sobre Desenvolvimento de extensões para o Chrome foi bem legal e mostrou como é simples desenvolver uma extensão e como ele consegue acesso fácil ao chrome apenas utilizando Javascript. E o mais engraçado é que o desenvolvedor do Chromed Bird fez uma pequena apresentação mostrando a extensão dele e ele tinha uma direct message com um link para um twit meu. Vai saber :P
Achei que a palestra sobre HTML5 seria a mesmice de sempre, mas aprendi muita coisa interessante com ela! Não sabia que agora existem buscas no estilo jQuery nativamente no Javascript. Algo como .search('#id') (não é esse método, mas existe), fora as dicas que ele deu e os exemplos que ele mostrou que valeram a pena. Vou procurar a apresentação dele na internet depois para dar uma olhada novamente, e se eu encontrar atualizo o post.

Novamente, teve outras palestras legais, mas essas são as que eu lembro, e aproveitei! :)

Nesse evento também encontrei velhos amigos como o Rubens Altimari da Whitehat empresa que eu já tive o prazer de trabalhar, e meu amigo Bruno Assis que sempre marcamos de conversar e nunca nos encontramos :P.

Minhas fotos do evento

Resumo

Foi uma semana Muito cansativa, fazia tempo que eu não ficava tão cansado assim. Entre um evento e outro teve as minhas seções de fisioterapia (para curar umas dores nas costas devido a uma queda), e também trabalhei bastante para compensar os eventos (e o mais legal é que foi uma parte divertida do trabalho para fazer!).

No fim das contas, tudo isso valeu muito a pena, aprendi bastante, conheci pessoas, revi outras pessoas, consegui manter o fluxo do meu trabalho, e descansei no final da semana! Portanto... Vitória! :D

Conto da migração para Rails 3

Unknown — Thu, 21 Oct 2010 00:00:00 +0000

Nesse post eu vou falar um pouco de como foi atualizar a aplicação que eu trabalho atualmente para Rails3.

Em uma segunda feira eu tive a brilhante ideia de aproveitar que as tasks que eu estava fazendo estavam dependentes de algumas coisas que ainda não estavam feitas, e resolvi começar a atualizar a aplicação para Rails3 só para saber o trabalho que ia dar, e no final do dia eu já tinha feito todas as alterações necessárias para o boot da aplicação e para rodar a suite de testes (não fazer os testes passar, apenas rodar!). Depois disso foi mais 1 dia para fazer todos os testes passar, e mais alguns outros testando a aplicação e resolvendo pequenos problemas de safe html e derivados.

Dicas para fazer a conversão do código

Tenha testes

Se não tiver testes, esqueça essa idéia e pare de ler o post, a menos que você queira quebrar sua app em produção.

Faça sua aplicação e suite de testes funcionar

Primeiramente, se você ainda não conhece, vale a pena dar uma olhada no plugin chamado Rails Upgrade que te dá um guideline do que você precisa ir alterando para tornar sua aplicação compatível com Rails 3. Esse plugin faz algumas coisas como criar o application.rb baseado no seu environment, te dar alguns guias das configurações que mudaram e tenta converter suas rotas para o novo padrão (vide próximo tópico) O primeiro passo a se tomar é utilizar o plugin (ou não, pode fazer manualmente também) e trocar as coisas principais para que sua aplicação pelo menos passe pela etapa de boot. Quando passar por esse passo vá para seus testes, e se for RSpec prepare-se para ter alguns problemas de conversão, por que algumas coisas mudaram do RSpec 1 para o RSpec 2, e você vai ter que lidar com os problemas de atualização dos seus testes tambem. A maioria das coisas que tive problemas foi com métodos que não existem mais como o have_tag por exemplo.

Não use o Rails Upgrade para a conversão das rotas

Como disse acima, esse plugin é um ótimo guia, mas tome cuidado com ele como solução final. Você pode dizer para ele converter suas rotas, mas tome cuidado, por que dependendo da forma que as suas rotas estão diagramadas o resultado que ele dá não é muito conciso. O que eu fiz foi utilizar a conversão dele apenas como estudo para saber como está a nova syntax e refiz o arquivo de rotas do zero.

Pare de usar remarkable

Eu sempre gostei de usar Remarkable para testar relacionamentos, validações e etc, mas remarkable no Rails 3 é uma grande porcaria. Os desenvolvedores que começaram o projeto ficaram sem tempo para o mesmo e deixaram na mão de outros, que não tem a mesma qualidade ou preocupação com o projeto, portanto, a menos que você queira ser o novo mantenedor do projeto e fazer as alterações necessárias para que funcione bem no Rails 3, fuja dele agora. O que eu fiz foi começar a usar o Shoulda para algumas coisas que me convinham, como por exemplo testes de relacionamento e validações. Para quem estiver interessado em fazer essa migração, eu fiz grande parte das trocas do que eu usava (validações e relacionamentos) facinho com grep e sed! Fiz um Gist disso.

Evite dependencias

Assim como o remarkable acima, cada outra gem/plugin que você está utilizando pode ter problemas com o Rails 3, portanto, antes de fazer a migração procure manter o menor número possível de dependencias no seu projeto, e as que você tiver veja se já possui uma versão funcional para Rails 3, e se não possuir você já pode se voluntariar para fazer ;).

Use o sufixo _html nos locales necessários

Suponho que as aplicações Rails estão usando os formatos de internacionalização do Rails, portanto suas string não estão perdidas pelas Views, Controllers e Models e sim estão em seus devidos arquivos de locale. Levando esse cenário óbvio em conta lembre-se de que você não precisa dar raw em toda mensagem que possui HTML por que Rails já faz isso para você quando você adiciona o sufixo _html na sua chave de locale. Exemplo:

not_yet: "**Ainda não**"

Ficaria:

not_yet_html: "**Ainda não**"

E assim ele não vai escapar automaticamente o HTML dessa chave.

Vá lidando aos poucos com DEPRECATION WARNING

Quando você rodar sua suite de testes pela primeira vez já vai ser bombardeado por uma quantidade monstra de _DEPRECATION WARNING_s, mas não saia atacando eles de uma vez, primeiramente tenha em mente fazer sua aplicação funcionar e você vai corrigir esses probleminhas aos poucos enquanto estiver corrigindo os erros ou desenvolvendo coisas novas. Felizmente a API do ActiveRecord não deixou de funcionar, portanto você ainda não vai precisar fazer grandes modificações para a nova syntax utilizando Arel por enquanto, o que vai tornar a migração menos dolorosa e você pode migrar aos poucos enquanto seu código já estiver rodando.

Dicas de organização para a migração

Crie um branch separado e altere aos poucos

Sim! Todos queríamos que toda a equipe parasse por alguns dias e fosse alterar o projeto para funcionar com Rails 3, mas todos sabemos que isso não é possível na realidade de ninguém. Então uma coisa legal para se fazer (principalmente quando se está trabalhando com controle de versão distribuído, onde branches não são tão penosos) é criar um branch e manter uma pessoa trabalhando nele enquanto os outros vão tocando o projeto, sempre com muita comunicação para evitar que as pessoas criem cada vez mais código legado que precisará ser migrado, até que chegue uma hora que você possa voltar para o master e ficar sem deploy por alguns poucos dias para que a aquipe termine o trabalho e faça alguns testes.

Ataque um problema de cada vez

Acho muito legal a combinação Rails + Ruby1.9, mas acho que as coisas ficam bem mais fáceis quando atacamos no estilo estripador (por partes), assim você tem um caminho a menos para analizar de onde vem o possível erro, e assim que terminar uma migração para Rails 3 já pode começar uma para Ruby 1.9 e ver o que vai quebrar apenas para essa implementação específica.

Use seu ambiente de homologação

Não sei como seu deploy funciona atualmente, mas talvez com a migração você precise alterar ele e é na hora que você for colocar no seu ambiente de homologação que você vai descobrir isso, portanto, use-o bem! :)

Conclusão e Saldo final

Fazer a migração para o Rails 3 foi mais simples do que eu imaginei, mas mesmo assim tomou vários dias para a conclusão. Nos meus calculos levou mais ou menos 2 dias só meus e uns 3 dias meus e de outro desenvolvedor, isso contando os problemas de merge e etc. Portanto acho que em 1 semana é possível migrar uma aplicação bem coberta por testes sem grandes problemas e sem precisar parar a sua equipe inteira por um grande período. Escolha aquela semana com um feriado e atualize sua aplicação. :)

Motorola Milestone e Android

Unknown — Wed, 08 Sep 2010 00:00:00 +0000

Muita gente tem me perguntado sobre o meu Android atual, um motorola Milestone, e resolvi postar algumas informações e opiniões sobre o aparelho e sobre o Android em si.

Primeiramente, gostaria de dizer que o Android é um sistema muito bom, e estou bastante satisfeito com as features, apps, SDK e etc.

Milestone

É um aparelho bem legal e na minha opinião é o Android mais "custo X benefício" do Brasil. Tem um hardware bom o bastante (processador 600 Mhz e 256 de RAM), que já dá para rodar alguns joguinhos legais e deixar o telefone com uma boa usabilidade.

Uma coisa que me agrada muito no telefone é o teclado qwerty físico, por que eu sempre estou conversando com alguém no Gtalk ou escrevendo algumas outras coisas, e eu tenho certeza que iria passar muita raiva com o teclado virtual (apesar de estar gostando do teclado virtual do Milestone quando está no modo horizontal).

A comparação do Milestone com o Nexus One dá uma grande diferença de performance, sendo que o Nexus vence por uma boa diferença (tem processador de 1Gb e memória de 512), mas como eu já disse antes, o Milestone é um ótimo custo X benefício para quem nunca teve um Android e quer uma linha "poderosa" :D

Android

O Milestone em particular vem com o Android 2.1, e a Motorola promete o Froyo (Android 2.2) para o primeiro trimestre de 2011. Uma pequena

lista de vantagens legais do Android:

Download de aplicações legais facilmente pelo Android Market
Muitas aplicações de qualidade no Android Market com Rating e comentários dos próprios usuários
Api de desenvolvimento bem legal e multiplataforma
Integração fantástica com os serviços do Google, até comecei a usar alguns que eu não usava só por que é MUITO bom.
Multitasking de verdadinha
Sua liberdade continua intacta

Problemas

Tenho visto pouquíssimos problemas no Milestone. O unico que eu vi até hoje foi um reboot do celular enquanto eu estava jogando, mas acho que eu exagerei um pouco no multitasking (para quem não sabe o Android tem um multitasking real, portanto, você precisa fechar algumas apps de vez em quando, por que elas ficam rodando em background)

Considerações

Eu recomendo muito comprar um Android, e o que eu recomendo atualmente no Brasil é o Milestone, por que você consegue sentir um gostinho do que o Android pode fazer sem gastar tanto assim.

Para quem tem ou está pensando em ter um Android, pode aproveitar para dar uma lida na lista de aplicações legais que eu estou mantendo com uns amigos.

E Aguardem mais posts meus sobre Android ;)

FISL11

Unknown — Sun, 01 Aug 2010 00:00:00 +0000

Finalmente depois de 4 anos planejando eu consegui ir para o FISL! :)

Para quem ainda não sabe, eu estou trabalhando na Locaweb desde o começo deste mês e consegui ir com a equipe deles para o FISL.

Esperava um conteúdo técnico melhor no FISL, e algumas palestras (ou a falta de boas palestras) me decepcionou um pouco, mas pelo que eu fiquei sabendo foi decisão do público os temas, então ficou meio incontrolável. Mas como eu sempre digo, a melhor coisa dos eventos não são apenas as palestras, mas também as pessoas que você conhece e os papos que rolam entre uma palestra e outra, e isso foi bem legal! :)

Algumas palestras que eu assisti:

Xen Ferramenta de administração da Conab

Foi um case interessante do pessoal da Conab que criou uma ferramenta para administrar as maquinas Xen que eles tem internamente. E é uma aplicação Django Open Source. :)

An Introduction to Qt: The toolkit that can take you anywhere

Quem me segue no Twitter há algum tempo deve lembrar de alguns posts que eu fiz falando de Qt, pois eu resolvi estudar Qt e GTK Just for fun, e no fim das contas eu gostei bastante de Qt (e quase nada de GTK :P). Nessa palestra vi algumas coisas introdutórias de Qt e descobri uma IDE para Qt (no estilo .NET mesmo de ficar arrastando coisas), que é a QTCreator e uma biblioteca de teste para coisas Qt, que é a QTestLib.

Libvirt: A biblioteca de virtualização

Palestra do meu amigo Eduardo Otubo, mas foi bem curtinha e eu só peguei o finalzinho. Como diria ele: “Não tem muito o que falar de LibVirt também”.

Crash course on Git

Palestra com o Scott Schacon do Github, que mostrou algumas coisas simples de Git, mas foi interessante assistir mesmo assim. Nos outros dias teve outras dele falando sobre branchs e como trabalhar com eles, que foi um pouco mais interessante, mas nada além do que eu já estava acostumado.

DeltaCloud: Many cloud one API

Outra palestra do Eduardo Otubo, que desta vez até fez uma citação para a Locaweb que talvez usará algo com DeltaCloud. Essa tecnologia é bem legal por centralizar várias APIs em um ponto único. :)

Segurança e desafios em cloud computing

Achei que essa palestra fosse mais sobre “como fazer cloud computing” mas nesse caso era mais “como usar cloud computing de maneira segura”, portanto não aproveitei muito a palestra.

Curso de Ruby e Rails

Durante o FISL teve 3 aulas do Daniel Lopes sobre Ruby/Rails. A primeira foi somente sobre Ruby puro e eu gostei bastante de ver ele passando o básico para a galera! Sinto falta de pessoas ensinando Ruby e não ensinando Rails…Por isso gostei bastante e acho que ele se saiu muito bem. Nos outros 2 dias foi algo mais Rails básico, portanto assisti pouca coisa. Mas valeu a pena para quem não conhecia, ou conhecia bem pouco a linguagem e o framework.

Analise de tráfego em redesw TCP/IP com tcpdump

Gostei muito dessa palestra! Foi bem conceitual sobre os pacotes e protocolos, mas teve algumas amostragem do que estava acontecendo usando tcpdump, e foi uma maravilhosa aula de redes em 1 hora. :)

Lapidando Ruby – Estudo de boas práticas

Eu já conhecia o palestrante (Maurício Szabo) de nome pelo Guru-SP e por outros lugares que eu já tinha visto esse nome (não me lembro bem onde). A palestra foi bem interessante, e o assunto se direcionou sobre umas opiniões do palestrante sobre determinadas coisas, como padrões, refactoring, testes e outras coisas. Concordo com muita coisa que ele disse e discordo de outras, mas esse era mesmo o intuito dele com a palestra, levantar questões sobre as coisas que ele considera boas práticas e ver as opiniões da galera. Gostei bastante da palestra.

Introdução a Go

Essa palestra me decepcionou bastante, assim como a linguagem em si. Não vi vantagens pelas quais eu poderia apostar na linguagem Go. :(

Ext4 – A nova geração dos Filesystems

Está entre uma das melhores palestras do FISL na minha opinião. Foi bem técnica e mostrou quais são as vantagens do EXT4 sobre os outros FILESYSTEMS focando bastante no EXT3. As vantagens do EXT4 são bem legais, entre elas o melhor tratamento sobre arquivos grandes, e algumas soluções de problemas com datas e etc. Gostei de entender a diferença dos dois.

Disponibilidade >= 99.999%

Uma palestra bem para Sysadmin, mostrando como eles fazem para sempre manter a disponibilidade das aplicações dele na empresa que ele trabalha atualmente. Gostei das práticas que eles usam de sempre fazer um snapshot da maquina de produção para poder fazer a homologação em uma maquina “espelho”, mas achei meio estranho o modo de gerenciar as configurações por pacotes, sendo que usar um configuration manager faria bem mais sentido.

Criando soluções inteligentes com Shellscript

Esperava bem mais dessa palestra e nem terminei de assistir inteira. Esperava que o palestrante mostrasse várias técnicas de Shellscript, mas na verdade ele estava mostrando um pequeno conjunto de scripts que faziam configurações e resolvi um problema que ele tinha. Mas para mim não era nada interessante a palestra.

oVirt – Ambiente minimalista de virtualização para servidores

A ultima palestra do FISL para mim. Fui mesmo para conhecer o oVirt e saber “qual é a dele”, mas o projeto não me impressionou muito.

No fim de cada dia do evento eu sai com uma galera diferente para bater papo, um dia com o próprio pessoal da Locaweb, outro com a galera do GUS-BR, e outras pessoas também!

Conclusão

O evento foi muito legal, conheci muita gente legal, assisti palestras boas, cresci bastante e estou pronto para o próximo.

Encontrei vários Rubyistas por lá (faltou apenas o Carlos Eduardo da e-Genial que tambem estava por lá mas não saiu na foto), inclusive a galera do Guru-RS que eu só conhecia por e-mail. Galera gente fina!

Encontrei a Letícia Figueira que eu já conheço há mais de 3 anos pela internet (via Rubylearning.org), pois ela também era uma Assist. Teacher quando eu participava mais ativamente, e nunca tinha conversado pessoalmente. Foi bem divertido. :)

E via Letícia eu acabei conhecendo a galera da Fande(que é uma empresa que atualmente trabalha com Ruby/Rails no RS), que são todos gente fina!

Fora outros amigos que encontrei aleatóriamente, como o Clauber Halic da MozBr, a Bruna Griebeler, o Gustavo Guanabara, Fabio Akita e outros.

Para quem quiser ver as fotos que eu tirei por lá é só ver no meu picasa. ;)

Obrigado Locaweb por ter me levado lá! You Rock!

Serviços legais de Março

Unknown — Thu, 01 Apr 2010 00:00:00 +0000

Como vocês puderam perceber (ou não) eu não postei sobre os serviços legais de fevereiro e tenho um bom motivo para isso: Não achei nenhum serviço que valia a pena ser mencionado e não queria fazer um post enchendo linguiça! :P

O meu ultimo post foi sobre o Yahoo Open Hack 2009, e lá eu pude conhecer muita coisa legal, e ver outras nascendo de projetos lá mesmo! Por isso tenho informações legais para essa série novamente! ;)

Vamos lá:

YQL

O YQL, é um serviço do yahoo que ajuda o desenvolvedor que quer trabalhar com dados de vários lugares a não sei preocupar em aprender cada uma das API's. O que o YQL faz é dar para o desenvolvedor uma linguagem muito parecida com SQL (um pouco mais limitada, mas lembra muito) para que o desenvolvedor possa fazer querys das informações que ele deseja de vários serviços. Grande parte dos serviços do Yahoo estão disponíveis utilizando YQL e você pode fazer vários testes utilizando o próprio console do YQL. Uma coisa legal é a posibilidade de criar algumas tabelas baseadas em dados de outros serviços, ou baseadas em .csv e outras coisas.

Enfim, vale muito a pena dar uma olhada.

Spaia.me

O spaia.me é um serviço bem legal para gerar widgets para seu site/blog. Ele faz buscas em serviços como o Twitter, Flickr, Del.icio.us e meme e traz os resultados referentes a sua palavra em um box "animado" por JQuery.

Esse gerador de widgets foi feito pelo Nuxlli e pelo Cipriani no Open Hack day! :)

Foursquare

O Foursquare é um serviço bem interessante para você postar sobre sua localização e fazer reviews dos lugares que você frequenta. Resolvi comentar sobre ele justamente por que comentaram comigo sobre ele no #brhackday e eu fui dar uma olhada na API, e vi os hacks legais que dá para fazer com isso. :)

JSFiddle

O JSFiddle é um lugar muito legal para testar Javascript. Ele te dá acesso a uma série de bibliotecas javascript (tais como JQuery, Prototype, Mootools e outras) para que você possa fazer testes e comparações de funcionalidade entre uma e outra utilizando o mesmo HTML / CSS. Aconselho muito o uso dela, principalmente se você está estudando uma biblioteca específica ou apenas quer saber se determinada biblioteca tem funcionalidades melhores do que a sua biblioteca preferida.

É isso ae galera! Espero que esses serviços sejam úteis para vocês! :)

Yahoo Open Hack 2010

Unknown — Mon, 29 Mar 2010 00:00:00 +0000

Para quem ainda não soube, no final de semana passado rolou o Yahoo Open Hack Day 2010! O intuito do evento é juntar uma grande quantidade de Hackers para criar serviços úteis utilizando informações públicas e de preferência utilizar as API's do Yahoo (havia premios para alguns hacks com elas).

Uma das coisas legais do evento é que nada é proibido com relação aos Hacks, ou seja, você pode fazer um Hack com as ferramentas do Google (não vai concorrer aos premios, mas poderá apresentar lá e tudo mais), todas as linguagens de programação estão permitidas, não somente hacks web eram permitidos, o que deixou a criatividade ir longe. :D

Equipe e idéia

Participei do evento juntamente com uma equipe que formamos no Ikwa, e chamamos a equipe de SleepyProgrammers.

Nossa idéia era fazer um site para marcar rolês fotográficos, e utilizaríamos para isso as API's do Flickr, Meme, Weather e Maps.

Ao chegar no evento e ver a palestra sobre YQL nós já percebemos que não seria necessário aprender a usar essas várias API's e apenas precisávamos aprender a usar o YQL e saber quais informações poderíamos retornar de qual serviço. :)

Metodologia e projeto

Como já estamos acostumados a utilizar Scrum no Ikwa nós resolvemos fazer o mesmo para o nosso projetinho. Começamos com uma planning meeting logo na primeira hora para poder dar uma estimada no que pretendíamos fazer, e logo depois dividir as tarefas entre os membros da equipe. Mais ou menos de 2 em 2 horas (ou um pouco mais) fazíamos umas stand-up meetings para manter todos atualizados. A noite percebemos que isso não estava sendo muito necessário por que estávamos em constante comunicação, mas mesmo assim resolvemos seguir o costume, afinal demorava apenas uns 4 minutos. :)

O projeto seguia bem, com layout legal e algumas buscas supostamente funcionando até mais ou menos as 9 da noite.

Os problemas

Já percebemos que a nossa busca não estava retornando exatamente o que gostaríamos de receber, mas deixamos para dar uma refinada nisso no final do tempo, para não ficar muito tempo presos nisso.
Tivemos um programador a menos (@_bojak) que infelizmente estava usando Windows (acreditem se quiser) por que o netbook que ele comprou (exatamente para evitar ter que usar windows no notebook velho que ele tinha) não chegou a tempo do evento. Muitas das coisas que são simples de se instalar/fazer em um "Unix like" são uma grande dor de cabeça para se fazer no Windows, portanto o @_bojak teve tantos problemas que chegou uma hora que desistiu de colocar a mão em código.
Algum descuidado da equipe criou a pasta "Views" no famigerado Textmate (escrevi uma gracinha aqui e apaguei para não gerar flame de textmate), e assim bugou a aplicação na minha maquina Linux, e me deixou um tempinho procurando qual era o problema. #fail
O Heroku não colaborou para funcionar utilizando o bundler, e depois de muito tempo tentando nós abandonamos o bundler e utilizamos oldstyle mesmo.
O nosso outro programador (@jorge_silveira) saiu (já tinha avisado que sairia) dizendo que voltaria e simplesmente deixou a equipe na mão (tem seus argumentos, mas essa é minha opinião...)

O fail do projeto

Depois desse monte de problemas eu já estava desmotivado com o projeto e comecei a ficar com bastante sono, portanto tirei umas 3 horas para dormir (fora o tempo que dormi na mesa), enquanto só o @_bojak ficou trabalhando motivadão (usando o computador do @rafaeltimbo que tambem estava dormindo :P).

Logo pela manhã sabendo que um programador tinha arregado (@jorge_silveira), um estava impossibilitado de trabalhar com seu próprio computador (@_bojak) e nossa busca não estava retornando coisas legais para continuar, nós decidimos que esse projeto ficaria para depois do Open Hack Day.

No fim das contas fizemos uma retrospectiva bem legal, onde vimos grande parte dos problemas que tivemos e boa parte das soluções tambem, foi bem legal! :)

O evento

Ok, nosso projeto não vingou mesmo, mas o evento valeu muito para mim! Aprendi coisas novas, revi amigos, conheci pessoas novas, conheci as API's do Yahoo, comi e bebi de graça, descobri que não devo acreditar nas palavras de alguns, descobri que algumas pessoas com certeza estarão na minha equipe novamente se quiserem.... E mais várias outras coisas!

No fim das contas eu tenho uma coisa para recomendar para quem não foi... Quando tiver o próximo, não perca a oportunidade! O evento vale muito a pena! :)

Para quem quiser ver as fotos que eu tirei no evento pode dar uma olhada no meu album do Picasa.

Linux, Vim, Screen e Pair programming!

Unknown — Mon, 29 Mar 2010 00:00:00 +0000

Aqui estou eu mais uma vez para falar mais uma das maluquices que eu fiz um bom tempo atrás mas não tive tempo de postar.

Primeiramente eu vou falar o que muita gente já falou muito bem, que é sobre screen e pair programming. Mas vou dizer como funcionou para mim. Alguns posts que eu li antes e depois de começar a brincar com screen e pair programming, e que eu gostei:

Primeiramente vamos começar com umas dicas do post do caike:

Para mim foi necessário alterar as permissões do Screen:

sudo chmod +s /usr/bin/screen
sudo chmod 775 /var/run/screen

Agora é só seguir a velha receita dos dois posts:

Primeiro usuário:

O primeiro usuário acessa o computador host via ssh
executa o comando screen -S nomedoscreen

Segundo usuário:

Acessa o servidor com o mesmo nome de usuário/senha do primeiro
executa screen -x

Pronto! As duas pessoas estão compartilhando a mesma tela agora e podem usar o Vim para programar (claro, qual outro editor seria, não!?).

Nunca consegui utilizar o screen multiusuário (como mencionado no post do caike) mas isso não é um grande problema. :)

Como eu usei

Primeiramente fiz um pair programming normal com o @mateuslinhares, onde nós dois ficavamos no mesmo screen conversando (estavamos há menos de 2 metros de distância), e cada um com seu teclado, podendo intervir a qualquer momento. Isso foi legal por que não precisávamos ficar dividindo espaço de um mesmo monitor ou de um mesmo teclado, e ainda driblava outros problemas que tínhamos na época.

Uma nova idéia

Na época desse pair programming estavamos com uma task grande e trabalhosa, mas podia ser feita individualmente, e provavelmente seria mais produtiva do que em pair programming, mas tinha uma particularidade muito interessante. Cada um de nós conhecia melhor uma parte do sistema, portanto, se mantivessemos contato contínuo isso ia acelerar o trabalho, pois precisávamos alterar/retirar algumas coisas que podiam ou não ser importantes para o sistema como um todo. Levando tudo isso em conta me surgiu uma idéia:

Por que não fazer tudo com um “semi pair programming”, onde cada um trabalhava no seu computador mas visualizando a tela do outro em um split.

Tanto eu como o @mateuslinhares estamos acostumados a separar o nosso vim em vários splits verticais e horizontais, ou seja, um split vertical do screen não seria o problema.

O que fizemos

Decidimos então seguir o seguinte script:

Setup das duas maquinas:

Vim
Screen
Um usuário em comum

PotHix :

com o usuário compartilhado executa um screen -S pothix na sua maquina
Abre um novo split no screen com o comando ctrl+a s
Nesse novo split acessa a maquina do Mateus e executa screen -x para acessar o screen que o @mateuslinhares criou na maquina dele
Volta para o split anterior e trabalha normalmente

@mateuslinhares

com o usuário compartilhado executa um screen -S mateuslinhares na sua maquina
Abre um novo split no screen com o comando ctrl+a s
Nesse novo split acessa a maquina do Mateus e executa screen -x para acessar o screen que o PotHix criou na maquina dele
Volta para o split anterior e trabalha normalmente

Seguindo esse script teremos os 2 utilizando um screen com um split, sendo que um split é para seu trabalho local e no outro você pode acompanhar e dar pitacos no trabalho do seu comparsa! :)

Benefícios

No caso dessa nossa task isso resolveu muito o nosso problema, por que conseguimos trabalhar em locais distintos mas sempre em constante comunicação, o que sempre trazia alguns comentários como:

PotHix: Ow… Não tira isso aí não por que vai quebrar tal parada.

ou então:

Mateuslinhares: Cara… Olha isso aqui no screen, dá para fazer na sua parte tambem.

Conclusão

Para mim foi muito bom e recomendo a todos para tentarem algo do tipo quando tiverem chance (a não ser que você use Textmate…nesse caso…boa sorte! :P)! A unica coisa que eu recomendo é utilizar 2 monitores, assim você pode deixar a tela do seu comparsa no outro monitor (divida os monitores verticalmente) e trabalhar com vários splits no seu monitor. :)

É totalmente possível trabalhar com 1 monitor apenas (foi assim que trabalhamos) mas você obviamente perde um pouco de espaço.

Espero que essas informações sejam úteis para mais alguém.

Qualquer dúvida ou sugestão deixe nos comentários. :)

Palestra sobre Vim

Unknown — Mon, 29 Mar 2010 00:00:00 +0000

Esse vai ser um post curto, apenas para deixar registrado algumas informações sobre a palestra de Vim que teve no sétimo encontro do Guru-sp (sim, eu fui o palestrante :D).

Primeiramente, já começo com uma desculpa, por que já faz mais de 2 semanas que palestrei e só agora estou fazendo esse post. :(

Foi bem legal palestrar para uma galera que já conhecia ao menos um pouco do editor. Quando eu estava planejando o que eu ia falar eu fiquei com uma grande dúvida de qual seria a minha linha de apresentação, por que eu não sabia quantos já conheciam o editor, portanto eu poderia chegar falando de coisas avançadas e ninguem entenderia nada, ou pelo contrário, se muitos conhecessem e eu chegasse falando de coisas básicas demais a palestra seria um saco. A minha solução para isso foi preparar os slides de uma forma que eu conseguisse falar mais ou menos de determinados assuntos baseado no conhecimento do pessoal. Os slides que saíram foram esses:

Quando perguntei para o pessoal quem já utilizava, quem nunca abriu (ou não conseguiu sair...heheh) e que usa como editor principal, eu descobri que estava equilibrado. Portanto segui uma linha mais comum.

Tive a sorte do agaelebe gravar (valeu Hugo!), e portanto temos o vídeo tambem:

Qualquer dúvida, comentário ou sugestão é só postar aqui! :)

Serviços legais de Janeiro

Unknown — Tue, 26 Jan 2010 00:00:00 +0000

E ae galera! Vamos para mais um post sobre os serviços legais do mes.

OpenDNS

Estranho eu falar de OpenDNS não? Já existe faz tanto tempo e muita gente já conhece/usa. O que me fez colocar ele na lista de serviços legais foi justamente as opções que você tem na web do OpenDNS!

Se você se cadastrar no OpenDNS você pode configurar muitas coisas legais, como por exemplo a página de endereço não encontrado, ou a página de tentativa de fishing, entre outras. Além de configurar essas páginas você pode tambem definir atalhos, para quando você tentar acessar algo como: "http://pothix" ele já redirecionar para "http://pothix.com/blog" por exemplo. :)

Heroku

O Heroku é bem conhecido pela comunidade Ruby, pois é uma das maneiras mais fáceis de se fazer deploy de uma aplicação simples, bastando poucos comandos para que sua aplicação já fique disponível na web como um subdomínio do Heroku!

Só para dar uma idéia da simplicidade, o que você precisa fazer para mandar sua aplicação para o heroku (estou assumindo que vc usa Git):

sudo gem install heroku
heroku keys:add path/para/sua/key
heroku create nome_do_proj
git push heroku master

E pronto! Sua aplicação já estará disponível em http://nome_do_proj.heroku.com

Caliper

O Caliper é um serviço web bem interessante para se obter métricas do seu código.

Uma das coisas que eu mais gostei no Caliper é que ele não exige cadastro para uso, você pode apenas colocar a URL do seu projeto Git e ele já gera os relatórios utilizando a gem metric_fu e mantém um link para acesso dos mesmos.

Como de costume os meus posts sobre os serviços legais do mes são curtos, portanto, eu fico por aqui! Espero que sejam úteis! ;)

Crontab dentro da sua aplicação rails com whenever

Unknown — Wed, 02 Dec 2009 00:00:00 +0000

Hoje estou aqui para falar de uma coisa que quando vi pela primeira vez ignorei por parecer uma coisa boba, mas olhando melhor eu percebi que é uma idéia bem interessante. O que a gem whenever faz é manter o seu crontab de uma forma mais Ruby, e melhor, dentro da sua aplicação!

A principio parece estranho tentar manter o crontab dentro da sua aplicação, mas ganhamos muitas vantagens com isso:

versionamento
menos acesso ao servidor
rapida atualização do crontab do servidor via capistrano
forma mais legível de ver o crontab

E tudo isso não influi no crontab que você já possui ( e que muitas vezes tem muita coisa que não é relacionada com a aplicação ), pois o whenever cria uma seção que ele atualiza mantendo a seção antiga onde está.

Para instalar o whenever é a mesma facilidade de sempre:

sudo gem install whenever

OBS: Lembrando que a primeira linha só é necessária uma vez, se você já tem o gemcutter no seu sources então ignore-a.

Depois disso execute:

wheneverize .

O comando acima vai gerar os arquivos necessários para a utilização do whenever ( básicamente o config/schedule.rb ).

E a partir de agora você já pode atualizar o seu crontab com as suas configurações feitas no config/schedule.rb executando o comando:

whenever --update-crontab suaaplicacao

Quando você passa como parametro a sua aplicação ele cria um bloco apenas para as configurações da sua aplicação no crontab.

Mas é claro que você não vai precisar acessar o servidor e executar esse comando toda vez que você alterar o arquivo de schedule, para isso você provavelmente deve estar usando o capistrano para ser mais DRY. Se estiver usando inclua algumas linhas no seu deploy.rb:

after "deploy:symlink", "deploy:update_crontab"

namespace :deploy do
   desc "Update the crontab file"
   task :update_crontab, :roles => :db do
      run "cd #{release_path} && whenever --update-crontab #{application}"
   end
end

OBS: Se você tiver problemas no deploy com essa linha ( como se o comando whenever não existisse ), tente adicionar o path absoluto para o whenever.

E com isso a cada vez que você fizer um cap server deploy seu crontab será atualizado com as configurações contidas no config/schedule.rb.

Veja alguns exemplos do que pode ter no seu schedule.rb:

every 4.minutes do
  rake "ts:in"
end

every 1.day, :at => '5:25 am' do
  rake "bla_bla"
end

every [:monday, :thursday], :at => '11:59 am' do
  command "sudo rm -rf /" # claro!
end

Nada do que eu demonstrei aqui é uma grande novidade, você pode ver mais exemplos de como usar no Railscasts e na própria página do plugin.

Espero que seja útil para mais alguem como está sendo para mim.

Dev In Sampa

Unknown — Wed, 02 Dec 2009 00:00:00 +0000

Nesse sábado, dia 28/11/2009 aconteceu aqui em São Paulo (obviamente! :P ) o Dev In Sampa! Um evento para desenvolvedores em geral, sem foco em uma determinada linguagem de programação, ou seja, um evento bem legal e pragmatico! :D

Perdi um pouco a hora, portanto não assisti o começo da palestra do José Valim, que por sinal é um assunto que muito me interessa, portanto recorri aos vídeos do @agaelebe para assistir o comecinho. Para quem quiser ver os vídeos confira no blip.tv do agaelebe.

Agora vamos para a programação e meus comentários:

José Valim - Tópicos de machine learning: classificação de textos

Como disse no começo do post, eu perdi o começo da palestra do Jose Valim por que eu me atrasei (foi por um bom motivo), mas compensei depois assistindo o vídeo. A palestra foi muito boa, e abordou um dos tipos de tema que eu gosto, machine learning é bem interessante! Essa é uma das coisas que eu pretendo estudar só por diversão, por que parece ser bem legal. O @josevalim fez sua tese sobre classificação de textos, portanto conhece bem do assunto e foi muito interessante ver as pesquisas dele consolidadas e simplificadas em uma apresentação. :)

Rodrigo Yoshima - Design de Software: As técnicas esquecidas...

O @rodrigoy fez uma palestra bem legal comentando sobre várias técnicas esquecidas sobre design de software, e muitos programadores que assistiram essa palestra devem ter se visto em várias situações por ele citadas ( eu fui um deles em alguns pontos ). Algumas das coisas citadas foram:

Design incremental

Nunca pense naquela história de "Preciso do pedido para poder fazer a tela de cadastro" sempre comece por aquilo que agrega mais valor. Faça as coisas sempre usando um pensamento incremental, criando testes para que quando você resolva um bug não crie mais outros por não saber as consequências de suas modificações. Sempre tomar cuidado com o design incremental para que ele não se torne um problema pelo mal crescimento da sua aplicação.

Tomar cuidado com arquiteturas monolíticas / egípcias - Arquiteturas difíceis de refatorar, que usam componentes pesados, quem ninguém sabe como foi feita e etc.
Separar a função de cada unidade, não deixando que o produto tenha que saber sobre vendas, por exemplo.
É melhor um design ruim com testes do que um design bom sem testes por que com testes você pode refatorar, agora sem testes a situação já muda bastante.

Entre outras coisas muito interessantes que eu não vou mencionar por que senão meu post vai ficar enorme, mas assista o vídeo e veja as dicas interessantes que ele dá.

Primeiro Coffee break para encontrar os amigos e bater papo! Tinha bastante gente do Guru-sp por lá ( @almeidaricardo, @shadow, @rafaelrosafu, @scalone, @bbcoimbra, @nelsonmhjr, @_bojak, @cassiomarques, @dcreq e mais um monte de gente! ), foi legal para bater um papo com os conhecidos. :D

Só para constar, o Ronaldp Ferraz (@rferraz) veio falar comigo sem crachá e sem cavanhaque, e eu obviamente não conheci, tinha que se apresentar formalmente ( ou seja, com cavanhaque! O @tinogomes já aprendeu! haha ). :P

Ronaldo Ferraz - Criando sua própria linguagem de programação

Palestra muito boa do @rferraz! :D

O assunto foi bem denso, mas bem interessante, ele mostrou alguns conceitos e informações interessantes sobre como criar e brincar com a sua própria linguagem de programação de uma maneira não tão difícil usando Treetop e Ruby. Como muitos já sabem o Ronaldo tem conhecimento infinito em linguagens de programação, portanto a palestra foi bem legal com vários exemplos em várias linguagens.

João S. O. Bueno - Desenvolvimento de jogos com Python

Puxa vida...Essa palestra foi um grande 417 ( Código de retorno do HTTP para Expectation Failed ), por que como muitos sabem eu adoro desenvolvimento de jogos, e fiquei muito feliz por ver uma palestra desse segmento nesse evento. Outra coisa que me entusiasmou bastante foi o fato de ser com Python, que assim como Ruby é uma linguagem que eu gosto bastante, mas em outra palestra que eu tinha visto ( no** CONISLI 2008** ) o palestrante não foi muito feliz com o conteúdo. Enfim, e fui com muita vontade de ver essa palestra.

No início da palestra quando falaram o nome do palestrante e eu o vi, percebi que parecia familiar, e por incrível que pareça...Era o mesmo do CONISLI 2008... Mas até aí tudo bem, agora o nível do pessoal é diferente e já se passou mais de 1 ano desde a ultima palestra, ou seja, essa prometia ser bem melhor.

Como puderam ver pelo começo do post, foi um grande engano meu, apesar de o palestrante falar que ia focar mais em jogos já que o pessoal já conhecia Python, ele ficou muito em Python e no finalzinho mostrou alguns joguinhos feitos em PyGame, como se a idéia da palestra fosse mostrar que Python é legal (que nós já sabemos! :D ) e dá para fazer jogos tambem. Enfim...Me decepcionou... :(

Intervalo para almoço

O Almoço foi meio corrido por que o evento estava meio atrasado, mas mesmo assim deu para conversar bastante com a galera do Guru-sp no shopping ( não me pergunte qual ).

Guilherme Silveira e Adriano Almeida - Do REST ao RESTFul

Na volta do almoço tivemos uma palestra teórica sobre REST e RESTful, que por sinal abriu muito a mente sobre o assunto. Mesmo o assunto sendo teórico o Guilherme Silveira e o Adriano passaram muito bem a idéia e souberam conduzir bem a palestra para manter o conteúdo bem dinâmico.

Nando Vieira - Escrevendo testes no JavaScript

Aqui um assunto que vem me interessando cada vez mais, testes! E como eu sempre gostei de Javascript, a palestra foi bem relevante. Infelizmente o Nando Vieira não conseguiu mostrar todos os exemplos que ele tinha planejado, mas foi bem interessante ver o live coding, e as amostras de testes para determinadas coisas. Gostei bastante da syntax do JSpec, não sei como fica a integração dele com o prototype ( que é o que eu estou usando atualmente no trabalho, mesmo preferindo JQuery ), mas pretendo dar uma chance para ele assim que possível.

Luis Cipriani - Web em tempo real com Ruby e XMPP

Bem legal o case que o Cipriani mostrou sobre a sua aplicação da maratona de basquete, achei muito interessante as ferramentas que ele usou, e vi que ele soube passar bem as informações sobre o XMPP que foram necessárias.

Coffee-break

Agora sim um coffee break que deu um tempinho para conversar com uma outra galerinha como o @rferraz, a @narwen, o @fabiokung e mais outra galera.

Ricardo Almeida - Buscas poderosas com Solr

Estava curioso desde o ultimo post do @dcrec sobre o Solr, e a palestra do Ricardo foi o ponto para tirar as minhas dúvidas. Vi muitas vantagens do Solr sobre o Sphinx e nenhuma do Sphinx sobre o Solr, acho que vale a pena tentar uma migração num futuro não tão distante.

Radamés Ajna - Arduino - Computação Física

A palestra do Radamés foi demais! Além do Arduino ser fantástico, o Radamés soube apresentar muito bem, mesmo com alguns problemas nos slides ele mostrou muito bem algumas coisas legais que dá para fazer com o Arduino, sempre com exemplos muito interessantes de coisas que já fizeram ou que ele pretende fazer. A interface para mexer com arduino realmente não parece ser tão complexa, e eu gostaria mesmo de ter algum conhecimento em eletronica nesses momentos, mas quem sabe algum dia eu tiro um tempinho para dar uma brincada. :D

Fabio Kung - Cloud Computing. E eu com isso?

Para fechar o evento tivemos uma palestra muito legal do Kung mostrando o que "ele acha" que é cloud computing, e os tipos de cloud computing que são oferecidos ( IaaS, PaaS e SaaS ). Ele mostrou como funciona e por que são usados os cloud computings atualmente, e como estão as experiencias dele com cluod computing atualmente. Achei a palestra bem legal, e é interessante ver as opiniões e experiências de alguem que realmente está vivendo essa parte de cloud computing.

Conclusão

O evento terminou bem atrasado ( mais de 20:00 ), mas valeu muito a pena ter ido. Há tempos estava sentindo falta de um evento que não levasse em consideração apenas uma linguagem de programação, algo que fosse mais pragmático mas que fosse totalmente voltado a desenvolvimento.

Parabens a todos os organizadores do evento e espero ver vocês novamente na próxima edição! :D

Serviços legais de dezembro

Unknown — Wed, 02 Dec 2009 00:00:00 +0000

Infelizmente não consegui postar sobre os serviços legais do mes de novembro por que eu estava cheio de coisas para fazer ( devido as provas de fim de ano, e meu curso é anual ), portanto não consegui agregar nada para novembro, e muito menos tempo para postar. Mas agora estou eu aqui denovo para postar sobre o que eu achei de legal na internet nesse meio tempo! E lá vamos nós:

Mocking Bird - Wireframes on the fly

O Mocking Bird é um site onde você pode montar wireframes para layouts de sites facilmente, como se você estivesse fazendo um desenho mas com elementos pré-determinados. Achei o serviço muito interessante, principalmente para mim que não manjo nada de fazer design, portanto eu posso dar uma olhada no que eu quero fazer usando os elementos pré determinados do Mocking Bird e quem sabe fazer um layout razoável para implementar, apenas revendo as cores com quem manja de verdade. :)

Collecta

O que eu achei interessante do Collecta é a quantidade de coisas diferentes que ele traz na busca, desde twitter até Github, e isso sem contar que é tudo em tempo real, e você pode ver realmente o que está acontecendo referente a um determinado assunto. O serviço parece ser interessante para cobrir eventos, por que da para ter uma visão geral do que está acontecendo em vários lugares ao mesmo tempo, ver fotos que postaram, comentários no twitter, vídeos no youtube e etc.

Buzz Volume

O Buzz Volume foi criado por dois colegas meus ( o [@dirs](http://twitter.com/dirs “Dirceu Pauka”) e o [@mauricio](http://twitter.com/mauricio “Mauricio”) ), e eu achei a idéia bem interessante! O que o site faz é agregar links que estão sendo bem falados no twitter, assim mantendo o usuário por dentro do que está sendo mais comentado, ou seja, um bom agregador de coisas famosas. :) Espero que nesse serviço coloquem uma feature de excluir asssuntos :P Bem, é isso! Esse post foi simples mas eu compri os serviços legais desse mes. ;)

Até mes que vem.

Rails Summit 2009

Unknown — Mon, 19 Oct 2009 00:00:00 +0000

Esse é um post para relatar como foi o Rails Summit Latin America desse ano! 😀 Já começo o post com um grande #win para a organização do #railssummit, por que eles tem tomadas para todos e wi-fi liberado para todos os participantes, o que ajuda para que pessoas como eu possam ficar postando no blog durante o evento, :) Vamos ao evento!

Rails Insurgency – Chad Fowler

A palestra foi muito interessante e o Chad Fowler falou sobre como é a dificuldade de implantar uma aplicação Rails em uma grande empresa quando você tem grandes gerentes que te enchem de perguntas do tipo: “Rails faz X?, “Rails faz Y” até que voc6e responda um não para que ele possa dizer: “Aháá! Então não podemos usar”. O Chad Fowler já foi um desses gerentes e decidiu passar a experiencia de um desses gerentes e por que eles pensam dessa maneira.

Uma outra coisa bem legal que o Chad comentou foi sobre fazer um modelo junto com o seu cliente na hora do planejamento, até por que você consegue fazer isso facilmente com o Rails e até mostrar uma pequena funcionalidade com um Scaffold sem muito transtorno, e seu cliente pode facilmente ver se é isso mesmo que ele está pensando.

Gregg Pollack – Na vanguarda da performance em Rails

O Greg Pollack falou sobre page scaling Rails, comentando sobre uma grande quantidade de plugins para medir e ajudar a corrigir alguns problemas de escalabilidade que são detectados. Foi apresentado ferramentas para melhorar performance de banco de dados, para verificar quais queries que podem ser melhoradas, onde podem ser incluídos índices e outras coisas bem interessantes.

No fim da palestra ele falou sobre o madmimi que ajuda a lidar com um dos grandes gargalos de aplicações, que é quando se tem que trabalhar com grandes listas de e-mails.

Para saber os outros assuntos que o Greg falou é só ver no blog do EnvyLabs: http://blog.envylabs.com/summit

Carlos Brando – Como o Rails funciona por dentro

Agora começa o problema por que temos que escolher uma palestra e eu fiquei em dúvida entre a palestra do Ilya Grigorick e a do Carlos Brando, mas no fim das contas resolvi assistir a do Carlos.

O Carlos Brando falou sobre como o Rails funciona por dentro, usando a sua experiência na criação de um framework (que ele está fazendo na nova empresa que está trabalhando), ele falou um pouco sobre como o Rails trata as requisições, como utilizar as coisas certas de Rails quando se está fazendo um framework, e comentou um pouco sobre o framework que ele está criando como exemplo.

Achei a palestra muito superficial…Achei que o Carlos fosse pegar pesado mostrando bastante coisa do Rails, mas ele decidiu mostrar algo mais simples pois ao mostrar para algumas pessoas percebeu que elas estavam achando meio massante. Enfim, como ele mesmo disse, não dá para agradar a todos, mas na minha opinião a palestra foi fraca :(

José Valim – Aprenda a customizar os geradores do Rails 3.0

A palestra do José Valim foi bem legal! Ele falou sobre o Thor e sobre os geradores do Rails 3, como você poderá facilmente customiza-los e como o thor pode te ajudar em suas aplicações.

Ele mostrou um pouco do motivo de se trocar utilizar o thor, e por que os antigos geradores são ruins do jeito que estão. Um exemplo legal foi mostrar como um plugin tem que fazer para gerar coisas, tomando como exemplo o RSpec, que com um spec_model vai ter que gerar migrations tambem, sendo que não é do escopo do RSpec ter que se preocupar com migrations, mas do jeito que está atualmente ele apenas pode trocar o script/generate model pelo script/generate rspec_model. Utilizando o exemplo anterior como base foi mostrado como os novos geradores vão ajudar nas tarefas dos plugins a partir de agora.

Gostei da palestra e acho que o José Valim conseguiu passar bem o que ele queria. :)

David Chelimsky – RSpec e Cucumber alem do básico

A palestra do chelimsky foi sobre o uso do RSpec e do Cucumber, que na minha opinião foi bem similar a palestra do ano passado, mas mesmo assim mostrou algumas boas práticas sobre RSpec que foram interessantes.

Eu ainda tive a chance de conversar com o Chelimsky no final da palestra para fazer umas perguntas sobre o Spork e como melhorar o tempo de execução dos meus testes que demoram muito para serem executados, tornando o desenvolvimento com o autospec não tão bom quando poderia ser.

Fabio Akita – Agile, além do caos

A palestra do Akita foi uma grande viagem de pensamentos aleatórios dele sobre a teoria do caos baseado nos estudos que ele tem feito nos últimos tempos. Eu achei que foi muita informação para um curto período de tempo para as pessoas, mas quem conseguiu abstrair muita coisa e entender qual foi a finalidade da palestra deve ter gostado bastante, por que a idéia central é bem interessante. :)

Matt Aimonetti – O Futuro do Ruby & Rails

O Matt falou sobre as novidades que virão no Rails 3, sobre o que poderá ser incorporado do merb e o quanto “plugável” o Rails 3 será. Ele não falou apenas de Rails, mas falou tambem um pouco de Ruby e quais são as novidades em termos de velocidade.

Desconferência

E chegou a hora que muitos estavam esperando, a desconferência! 😀

Na ultima desconferência o Elomar deu show falando um pouco sobre grupos de estudo, e muita gente estava esperando coisas legais para esse ano.

Teve muita coisa interessante, mas infelizmente não pude ficar até o final por causa da minha faculdade, mas o que pude ver foi:

Pessoal do Guru-sp apresentando o grupo e falando sobre o crescimento e futuras atividades (eu fui o primeiro a falar! 😀)
George Guimarães falando do Devise
Aldo França contando sua história para aprender Rails e fazendo um blog em 15 minutos ( com 11 anos de idade )
Guilherme Chapiewsky e Henrique Bastos falando sobre os eventos e grupos que eles participam no Rio

Sei que teve muito mais coisas legais alem disso, mas essas foram as unias que eu pude ver e achei todas bem legais! 😀

Acho muito interessante essa idéia de desconferência, pois serve tanto para integrar o pessoal e dar risada quanto para apresentar projetos interessantes e muito úteis para alguns.

Sem contar que eu ganhei um Ipod nano da ThoughtWorks em um sorteio pouco antes da desconferência. 😀

Manhã do primeiro dia

Agora vem a parte triste…Não pude estar no evento no segundo dia de manhã. :(

O ikwa não liberou todos os programadores para ficar lá em tempo integral, portanto fizemos um revezamento, e para mim ficou o segundo dia de manhã.

Perdi duas palestras que eu gostaria muito de assistir. A primeira é do Carlos Vilela que falou sobre o uso do Ruby na ThoughtWorks e a segunda é do Nando Vieira que estava falando do Ruby 1.9.

Uma coisa que me animou um pouco foi saber que as palestras eram simultâneas, portanto eu ia perder uma de qualquer jeito.

Marcos Tapajós – CouchDB no Rails

Como não pude estar no evento no segundo dia de manhã eu já cheguei direto para a palestra do Tapajós sobre CouchDB, que por sinal foi bem interessante! O Tapajós mostrou um pouco de como é trabalhar com CouchDB e como deve ser a mudança de paradigma da saída de um banco relacional para ir para um banco orientado a documentos.

Como o próprio Tapajós disse, a idéia da palestra dele era dar um Overview do couchDB e depois abrir para perguntas para tirar as dúvidas do pessoal, e na minha opinião ficou muito bom! 😀

Bruno Miranda – Rails não escala

O Bruno Miranda apresentou “juntamente” com o Jason Seifer (infelizmente o Jason Seifer não pode estar no railssummit por problemas com a viagem, portanto apenas enviou vídeos da parte que ele ia falar) sobre “Rails não escala”, falando sobre a aplicação que está em baixo do canal de audio do MSN e como eles conseguem manter uma infra escalável usando Rails.

Vinicius Teles – Do serviço ao produto

Uma das melhores palestras do Rails Summit ( as palestras não técnicas são sempre as mais marcantes, por melhor que sejam as técnicas… ), onde o Vinícius contou sua história passando por bons e maus momentos com a sua empresa, começando com serviços e terminando em produto.

Coisas interessantes da palestra do Vinícius foi o grande enfoque em “reserva”, ou seja, sempre tenha uma reserva em caixa para segurar a sua empresa nos piores momentos ou ajudar quando vem aquela grande oportunidade. Apenas investir em passivo ( como carros por exemplo ) quando isso não for um grande empecilho, por que no começo um carro (por exemplo) só vai te trazer prejuízo com desvalorização e manutenção.

O Vinícius deu ótimas dicas para quem quer começar uma empresa, várias dicas de experiencias que ele passou, e me animou muito a preparar as coisas par a empresa que eu vou abrir no futuro. Acho que já posso começar a me preparar. 😛

Obie Fernandez – Dominando a arte do desenvolvimento de aplicações

Outra palestra no mesmo nível da palestra do Vinícius ( também não técnica ), portanto muito boa! 😀

O Obie Fernandez falou sobre como dominar o desenvolvimento de aplicações, e achei muito interessante os exemplos que ele passou sobre musica, comentando da quantidade de esforço de um grupo de músicos em termos de horas e o que isso implicava em seu nível. Ainda sobre o tempo de estudo, não é “apenas estudo” por que pratica não leva a perfeição, “prática perfeita leva a perfeição”. Programação é como musica, é sempre bom pegar musicas dos outros para estudar, por que assim você pode aprender sutilezas para fazer a sua.

A palestra do Obie assim como a do Vinícius teve frases chave como:

Se eu estiver trabalhando e um dia descobrir que eu não estou feliz eu simplesmente saio
Fuck the enterprize ( muito boa! haha )
Pratica não leva a perfeição, pratica perfeita leva a perfeição

Gostei bastante da palestra, e bateu certinho com algumas coisas que estou pensando para os meus estudos para os próximos tempos.

#horaextra

O #horaextra foi muito legal! Tivemos um problema com o primeiro bar que fomos por que não podiam entrar menores e nem com short, portanto o Mergulhão e o Aldo ficariam de fora, então o pessoal foi para outro bar, que ficava do lado desse e lotamos o lugar 😛

Como o bar era pequeno para a quantidade de pessoas, as coisas demoravam um pouco para chegar, mas nada que uma boa conversa não pudesse ajudar você a relevar isso. A mesa era gigante, mas as pessoas que a voz alcançava eram: Carlos Brando, r4f4e1, Vinícius Baggio, Shadow e Agaelebe.

Batemos papo por um bom tempo, com participação de mais uma galera ( Akita, Rafael Rosa, Thiago Scalone …. ), e acabei saindo de lá mais de 00:00.

Aqui chega o fim do evento e o que fica são os bons momentos passados por lá, o conhecimento adquirido e a vontade de participar novamente no ano que vem! Parabens aos organizadores ( e patrocinadores! ) do evento, por que ficou ótimo!

Se quiser ver as fotos que eu tirei no evento veja o album no meu picasaweb.

Serviços legais de outubro

Unknown — Sun, 04 Oct 2009 00:00:00 +0000

Já estava me esquecendo de postar sobre os serviçoes legais desse mes! :P

Estava com poucos quando lembrei, mas não demorou muito para que eu lembrasse de alguns muito bons. Vamos lá!

yUML<

O yUML é um serviço para se criar UML facilmente utilizando apenas uma URL com determinadas marcações. O caike que me mostrou no ultimo post quando eu tinha mencionado sobre criação de UML. Valeu Caike!

Gliffy

Continuando em diagramas e UML temos o Gliffy que também faz uma grande quantidade de diagramas diferentes.

Esse quem me mostrou foi a Suelen! Valeu Suelen! =*

Pivotal Tracker

Para quem não connhece, o PivotalTracker é uma ferramenta para gestão de projetos utilizando Scrum! Ele utiliza várias ferramentas que são muito úteis quando se tem uma equipe que está aplicando a metodologia Scrum, como gráfico burndown, média automática de pontos por semana, agendamento automático de tarefas de acordo com a quantidade de pontos por sprint da equipe e mais outras coisas bem interessantes! Já trabalhei utilizando o Pivotal e recomendo!

Scrumy

O Scrumy é outra ferramenta muito interessante e bem simples para se trabalhar com Scrum, principalmente para equipes remotas. Ele cria um kanban board virtual, onde você pode arrastar os post-its para as próximas áreas ( todo, wip, verify, done ), e ter uma visão mais ampla das atividades facilmente.

Esse mes é só isso! Espero que seja útil para alguém!

Instalando e configurando o monit

Unknown — Thu, 10 Sep 2009 00:00:00 +0000

Esses dias eu peguei para instalar o monit no servidor da empresa que eu trabalho e sofri um pouquinho com algumas coisas básicas, portanto decidi postar aqui para que seja útil para quem quer começar a utilizar o monit.

Se você usa Ubuntu, você pode fazer download do Monit por apt-get:

sudo apt-get install monit

Se você não usa Ubuntu ou quer a ultima versão do Monit, então faça download do tar.gz http://mmonit.com/monit/download/ e compile.

O Monit tem 2 dependencias:

bison
flex

Eu resolvi as 2 facilmente utilizando o próprio apt-get:

sudo apt-get install bison flex

Agora é só partir para compilar os fontes! ( prefiro compilar dos fontes em certas ocasiões para pegar a ultima versão ):

./configure
make
sudo make install

E pronto! Lá está o seu monit instalado! Agora é o momento da configuração. :D

O monit utiliza o arquivo chamado .monitrc para saber o que deve ser monitorado e com quais parâmetros, portanto crie um arquivo na sua $HOME com o nome de .monitrc:

vim $HOME/.monitrc

Claro que usarei o vim para isso (qual outro poderia ser né? haha). Agora você deve criar o seu próprio arquivo de configuração dizendo o que o monit deve monitorar e quais critérios deve usar.

Você pode pegar alguns exemplos de arquivos como o do pessoal do mongrel, ou até mesmo da documentação oficial do monit e criar o seu baseado nele. A syntax desse arquivo é de fácil entendimento. :)

Para e-mails eu utilizei a minha conta do Google Apps com a seguinte configuração:

set mailserver smtp.gmail.com port 587 username "pothix@pothix.com" password "abc123" using tlsv1, with timeout 15 seconds

Com todas as configurações arrumadas o monit já pode ser iniciado:

monit

E agora você já tem vários comandos para utilizar, é só dar uma lida na documentação do monit para ver o que é possível fazer.

Espero que seja útil para quem ainda não usa nenhuma ferramente de monitoração e gostou do monit. :)

Serviços legais de setembro

Unknown — Thu, 10 Sep 2009 00:00:00 +0000

E lá vamos nós novamente para mais um post sobre os serviços legais que eu encontrei esse mes.

Creately

O Creately é um site para se fazer diagramas! Eu estava procurando por isso faz bastante tempo e nunca tinha achado um satisfatório, mas esse parece ser muito bom!

Com ele é possível fazer uma grande quantidade coisas, como diagramas de classe, fluxograma, esqueletos de layout e mais um monte de coisas legais e depois exportar para alguns formatos.

Groove Shark

O Groove Shark é um site fantástico para se ouvir musicas! Sabe quando você está na faculdade na internet pesquisando sobre um trabalho e tem aquela saída para fone no computador e você pode ouvir musicas mas não tem um lugar legal? Acesse o GrooveShark faça uma pequena playlist e se divirta.

Gostei por que eles tem uma grande variedade de musicas lá e a interface é bem leve e bonita.

TutsPlus

O TutsPlus é um site que possui uma grande quantidade de tutoriais de qualidade sobre vários tipos de assuntos. O que achei interessante é que os materiais são divididos em sites diferentes e todos os tutoriais são moderados, portanto quase todo o conteúdo que você vê por lá é de muito boa qualidade.

Eu acompanho as atualizações do NetTuts por que sempre tem um conteúdo que me interessa referente a web, seja Javascrit, PHP, Rails ou várias outras coisas interessantes.

Bem, é isso! Espero que esses links sejam úteis para mais alguem além de mim! :D

Um pouco sobre o Vim

Unknown — Fri, 14 Aug 2009 00:00:00 +0000

Aqui começa uma série de artigos sobre por que eu gosto de usar o VIM para programar.

Uma das primeiras coisas que eu gostaria de comentar é sobre a quebra de paradigma que você deve ter quando começa a usar um editor como o vim que tem vários modos de operação, ou seja, não é mais apenas digitar, pois cada modo de operação tem o seu modo de agir. Os modos de operação são os seguintes:

Inserção
Visual
Normal
Comandos

Modo de inserção

O modo de inserção é um modo simples para se inserir texto sem nada muito complexo, você se sentirá usando um notepad se usar somente o modo de inserção.

Modo visual

Com o modo visual você pode selecionar facilmente trechos de texto, linhas inteiras e blocos de texto. Um exemplo bem legal de uso de blocos no Vim pode ser visto no blog do TaQ.

Modo normal

Agora sim as coisas ficam legais! No modo normal, que é o modo que você mais fica no Vim, você pode fazer as coisas mais interessantes!

Ok, falei...falei...e não mostrei o por que o modo normal é tão poderoso né? Bem, são coisas como essas:

Dentro de aspas podemos dar um ci" e ele já excluiria todo o conteúdo que está dentro das aspas e deixaria você em modo de inserção para inserir um novo conteúdo
Parar em cima do número 20 e quer adicionar 7? Apenas faça ctrl+a e ele fará a soma em cima desse número
E se ao invés de soma vc quiser a subtração dos valores acima? Apenas faça ctrl+x e ele fará a soma em cima desse número
É claro que você não vai ficar repetindo esse monte de coisas que você fez aí em cima se tiver várias ocorrências e você não quiser fazer um "find and replace", por que você pode usar o . (ponto) para fazer a sua ultima ação novamente.
Quer trocar as linhas de posição? Moleza! ddp ( sendo dd para excluir uma linha, que fica no buffer, e p para colar a linha do buffer )
Está no começo da linha e quer ir para aquele parentese? f( e pronto, você já estará lá!
Quer ir para um caracter antes do parentese? t( ta na mão! :)

Enfim...Tem muitas outras coisas legais a se fazer sem que você precise tirar a sua mão do teclado.

Modo de comandos

E o modo de comandos é onde você tem uma segunda linguagem de programação alem da que você está usando pra programar, e lá você pode tanto usar comandos de loop como:

for i in range(1,10) | put ='192.168.0.'.i | endfor

OBS: créditos ao Sergio nesse post

Que imprime uma faixa de IPs de 192.168.0.1 até 192.168.0.10.

Ou você pode alterar as funcionalidades e opções do editor utilizando :set ou outras comandos interessantes.

Use o Vim como ele foi feito para ser usado

Outra quebra de paradigma que deve ser usada é usar "hjkl" para se movimentar pelo texto, sempre usando os dedos indicadores sobre o "j" e o "f" que é o padrão de digitação, e você vai ser que você vai precisar tirar a mão do teclado para fazer outras coisas poucas vezes, e pelo menos para mim as coisas parecem bem mais fáceis. Isso lhe força a sempre usar esc (ou ctrl+[) após fazer alguma coisa, deixando o modo normal livre para uso.

Customização

O Vim pode ser facilmente incrementado com plugins, temas e outras coisas que tornam ele bem customizável, e você pode deixar ele com a sua cara. Atalhos são facilmente configuráveis no seu .vimrc, assim como configurações como highlight de busca, espaçamento para scroll, e mais muuuiiitas opções que obviamente não caberão nesse post.

Concluindo

A idéia desse post é falar que para se usar vim você precisa estar disposto a mudar muita coisa que você sabe, e a curva de aprendizado não é uma das mais fáceis, mas quando você está no meio dela você percebe o quanto é legal e acaba se viciando no negócio! hehe

Como o Vim é bem configurável pode acontecer de você ficar tentando implementar ele para ficar igual ao seu antigo paradigma ( modo de inserção para sempre ), mas isso não vai de ajudar muito e vai te abstrair toda a força do Vim.

É isso! Nos próximos posts sobre vim pretendo postar dicas, referências legais e falar bem mais aprofundadamente de algumas ferramentas.

Instalando o Allegro 4.2.2 no Linux x86

Unknown — Wed, 12 Aug 2009 00:00:00 +0000

Como mencionei no meu ultimo post eu parcicipei do GameJam do Itaú cultural e desenvolvi um jogo com Allegro. Agora com o jogo pronto estou criando arquivos executáveis para divulgar e tinha me esquecido da diferença de arquitetura no Linux, assim compilei apenas para meu Linux x64.

Quando me dei conta que não funcionou no computador do trabalho por que eu tinha um binário x64, eu tive que instalar o Allegro no computador de lá para poder fazer funcionar também em Linux x86. Pensei eu:

"Vai ser moleza, assim como foi instalar o Allegro 4.2.2 no notebook x64"

E lá fui eu:

./configure
make

Ué...Deu um problema bizarro com o FNSTSW no make, então não vai ser tão fácil assim...E lá vamos nós procurar na internet. Procurando eu descobri que tem realmente um erro em uma parte Assembly do código do Allegro para x86 que está errada na versão 4.2.2 que provavelmente foi consertada nas versões futuras, mas nesse caso tive que arrumar na mão:

No arquivo src/i386/icpus.s alterar a seguinte linha (tirar a que tem um menos e colocar a que tem um mais):

fninit
movl $0x5A5A, %eax
-   fnstsw %eax
+   fnstsw %ax
cmpl $0, %eax
jne is_fpu_not_found

E assim eu consegui compilar certinho! :D

Quando tentei rodar meu binário me deparei com o seguinte erro: "error while loading shared libraries: liballeg.so.4.2: cannot open shared object file: No such file or directory" ¬¬

Pesquisando na internet novamente eu descobri que estava faltando eu adicionar o diretório /usr/local/lib ao meu LD_LIBRARY_PATH:

No meu .bashrc:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

Editar o meu arquivo /etc/ld.so.conf e incluir /usr/local/lib no final do arquivo e depois rodar o comando ldconfig como root ;)

Com isso eu consegui finalmente compilar ojogo e fazer o meu binário rodar o meu jogo normalmente. :)

Espero que seja útil para mais alguem.

GameJam

Unknown — Wed, 12 Aug 2009 00:00:00 +0000

Como alguns sabem no final de semana passado ( dias 7, 8 e 9 ) eu participei do GameJam do Itaú cultural.

Nesse evento os participantes tinham que formar equipes de até 4 pessoas e fazer um jogo em 48 horas, sendo que o tema ao qual o jogo devia responder só seria passado na sexta feira as 19, e teríamos até as 19 horas do domingo para entregar o jogo pronto utilizando qualquer plataforma para desenvolvimento.

Pois bem, o que eu falei acima resume bem as regras do evento, agora vamos a minha situação. Fiquei sabendo na segunda feira pelo CrociDB que teria esse concurso e que tinha até quarta feira para se cadastrar, e eu tinha acabado de fazer uma mini-cirurgia para tirar um dente, portanto estava sentindo dores e tomando 4 tipos de remédios diferentes e não pude confirmar nada devido a esse motivo, mas a vontade era grande. Enquanto eu não confirmava o CrociDB ia procurando pessoas para a equipe.

Quarta feira (último dia para inscrição chega) e eu já estava um pouco melhor e decidi me inscrever! Procurei por outras pessoas para compor a equipe, alguns descartei logo de cara por que sabia que ia ficar arrumando desculpinha para não participar, ou não teria peito o suficiente para aguentar a competição, então nem chamei, outros sabia que infelizmente não poderiam participar por motivo de força maior (fez falta hein Rafael Masoni) , e teve ainda os últimos que eu achei que participariam e fui chamar mas me decepcionaram...

Início do contest

Sexta feira tudo preparado e lá vou eu as 19 para o Gamejam (que foi na faculdade Anhembi Morumbi), e após me perder um pouco ( para variar ) cheguei em cima da abertura e recebemos o tema:

"Maquinas e computadores podem tomar decisões inovadoras?"

E com isso lá se vai o nosso pensamento...

Criar um robô em 2d no estilo side scroller?
Criar um robô fazendo algum tipo de shooter?
Criar um braço robô que faz algo?
Como ele seria inovador?
Ele seria inovador?
Como são as decisões dos computadores atualmente?

E com essas várias perguntas chegamos a conclusão que um computador sozinho não pode tomar decisões inovadoras, ele apenas é programado para uma determinada finalidade, nunca cabe a ele as decisões finais com novas idéias. Com isso em mente nosso game foi baseado num braço robô que distribui caixas num armazém seguindo sua própria ordem, supostamente tentando uma maneira inovadora de organização de cores que pode ou não estar certa, e cabe ao jogador organizá-la da melhor maneira possível. Obviamente a idéia inicial não se fechou tão fácil, e fomos desenvolvendo ela de acordo com a evolução do game.

Com uma base inicial desenvolvida passamos para o desenvolvimento! :D

Preparamos o ambiente com Allegro e algumas classes que o CrociDB usa para facilitar algumas coisas e eu dei uma introdução sobre o workflow do Git para trabalhar utilizando controle de versão. Usamos um roteador para conectar os 2 notebooks e compartilhar um repositório para os códigos, por ssh mesmo, que infelizmente deixava a transferência muito ruim devido ao uso do Cygwin no Windows, mas não fui um grande empecilho, foi apenas chato.

Tenho que admitir que eu sou um zero a esquerda em Allegro e fui com a cara e a coragem participar desse contest, mas eu sabia que isso me traria muita experiência, por que eu sei que o CrociDB conhece bastante de Allegro e de desenvolvimento de games em si, e eu só comprovei isso durante todo o contest, ele já conhecia bem o conceito de desenvolvimento de games e tem bastante experiência com erros que podem acontecer.

Ficamos programando desde as 21 mais ou menos até as 5 da manhã e resolvemos ir para casa descansar para voltar no sábado a noite e ficar até terminar o game. A primeira vista achei o pessoal das outras equipes meio acuado, cada equipe isolada em suas mesas, excluindo apenas o pessoal que já se conhecia ou que era da faculdade.

Momento Hard work

Voltei no sábado as 19:30 para a programação e o CrociDB já estava por lá programando fazia alguns minutos e já tinha resolvido alguns probleminhas. Então já começamos a programar outras funcionalidades e fazer os desenhos para o jogo, que por sinal foi a parte mais difícil para nós, tendo em vista que nenhum dos dois tem a arte do desenho assim como as outras equipes tinham ( vi muitos desenhos e trabalhos legais ). Eu assumi uma boa parte dos desenhos para deixar o CrociDB mais focado na programação.

Durante o domingo tivemos vários problemas, como o não funcionamento do teclado do notebook do CrociDB, nos fazendo perder um tempo e ir para o laboratório usar um teclado USB, que levou a outro #fail, por que levamos o roteador e não prestamos atenção que a fonte não era bivolt, assim queimando a fonte do roteador...Ou seja...Nada de Git na parte final do projeto...

No laboratório conseguimos finalizar o jogo e encontrar umas midis legais até as 14:30 mais ou menos, quando preparamos as coisas para entregar o projeto final. Ao entregar o projeto e ver a organizadora testando percebemos que faltou uma dll para o allegro funcionar no Windows, e tivemos que pegar o projeto de volta umas 2 vezes para encontrar a dll certa, mas enfim funcionou. :)

Networking

Depois de entregar o projeto aproveitamos para fazer um Networking com alguma das outras equipes. Durante o evento estávamos sempre vendo algumas pequenas cenas dos outros jogos e algumas ferramentas, e uma que chamou bastante a atenção foi da equipe que estava ao nosso lado (Danilo, Gabriel, Theo e o Mario que eu não conheci) que estava desenvolvendo um game totalmente em blender! (assim que eles divulgarem o game eu posto o link aqui). O game deles ficou muito legal e o pessoal é muito gente fina também, foi muito válido conhecê-los! :)

Vi por cima mais alguns games que estavam em fase de produção ainda, e conheci algumas outras pessoas como o Danilo Vin (só conheço ele assim até agora...hahaha) que estava fazendo as artes do grupo dele, muito boas por sinal, mas não vi o jogo finalizado. Revi tambem o Speeder já tinha visto na campus party mas não tinha conversado muito.

Considerações

Finalizando, eu acho que esse contest foi muito legal,dormi apenas 40 minutos de sábado para domingo, mas foi minha primeira experiência com competição de desenvolvimento de games, meu primeiro contato mais próximo com Allegro, revi alguns conceitos de C++, conheci pessoas interessantes, vi alguns jogos serem criados do zero... Mesmo se nosso jogo não ganhar (o que é provável....hehe) esse contest valeu muito a pena! O nosso game não ficou exatamente como queríamos por que além dos problemas, não conseguimos aplicar todas as idéias que tínhamos em apenas 48 horas.

Uma coisa que me deixou muito feliz foi ter conseguido fazer esse jogo usando apenas Software Livre! Utilizamos Inkscape, Gimp, Allegro e GNU/Linux. O Croci utilizou Windows para compilar a versão windows do jogo, e não tivemos sequer um problema de compatibilidade entre plataformas.

Para quem quiser dar uma olhada no nosso game, pode baixar ele no GitHub (o código não está um dos melhores, mas leve em consideração que foi um contest de 48 horas...hehe):

Código fonte Download do pacote

executáveis no diretório bin

Serviços legais de Agosto

Unknown — Thu, 06 Aug 2009 00:00:00 +0000

E lá vamos nós com mais um post (que felizmente estou conseguindo manter mensal) sobre os serviços legais que eu vi no mês passado e estou usando esse mês.

TypingWeb

O TypingWeb é um serviço web que possui vários tutoriais para aprender a digitar corretamente. Eu estou treinando digitação já faz um tempo utilizando o TypeRacing e um programinha para Linux chamado gtypist que tambem é bem legal para treinar. Achei esse site fantástico, e o mais legal de tudo é que tem uma versão em português, então eu posso passar para outras pessoas (como a minha mãe por exemplo) que tambem querem aprender a digitar melhor mas não se dão bem com o inglês.

GetClicky

O GetClicky é serviço de estatísticas assim como o Google Analytics, mas ele possui muitas ferramentas interessantes, como monitoramente de palavras chave no Twitter, estatísticas em tempo real e mais algumas coisas interessantes que faz valer a pena pelo menos testar o serviço! ;)

LastFm

Sim, estou falando da Last.fm que já está a tanto tempo aí, mas resolvi comentar por que eu estou lá há mais de 1 ano e só agora comecei a utilizar de verdade. Quando eu entrei pela primeira vez para saber como funcionava eu fui no site e tentei ouvir várias musicas. Umas eram cortadas, as playlist só podiam ser tocadas por usuários premium e não sei o que...Ou seja, achei uma porcaria. Nos ultimos dias eu conversei com um colega meu que me disse que deixava seu player dando tracking das musicas que ele ouvia e mandando para o last.fm, e finalmente eu descobri a finalidade do last.fm (noob), e realmente é bem legal ter um perfil numa rede social de musicas, onde seus amigos podem ver o que você anda ouvindo e comparar automáticamente o perfil musical.

Bem, esses são os 3 serviços que eu tenho para compartilhar esse mes! E espero que sejam úteis para vocês assim como são para mim. :)

High Performance Websites

Unknown — Thu, 30 Jul 2009 00:00:00 +0000

Mais um dos livros que eu consegui terminar de ler nas férias! O livro fala sobre performance de front end, como fazer as suas páginas carregarem mais rapidamente e fornecer uma melhor experiência para o usuário.

O livro começa explicando um pouco sobre o HTTP, seus métodos e utilizações, e depois inicia as sobre as 14 regras para ter um website mais performático. Eu vou tentar mostrar um pouco de cada uma das regras que o livro aborda, mas é claro que sem os grandes detalhes, comparações e exemplos que o livro dá, que são muito amplos e interessantes para se entender, mas vou dar uma visão geral de qual é o conteúdo da regra, para te chamar para comprar o livro e ler (ou não...hehhe).

As 14 regras são:

Faça menos requisições HTTP

Obviamente se tivermos menos requisições HTTP teremos páginas mais rápidas, então o livro recomenda várias técnicas legais como combinar imagens e usar estampas CSS, combinar scripts para evitar várias chamadas, assim chamando um script só, e tambem combinar folhas de estilo.

Use uma Rede de Distribuição de conteúdo

Distribua seu aplicativo de diferentes servers distribuídos geograficamente, pois assim você conseguirá entrega de pacotes mais rapidamente para determinados tipos de usuarios.

Adicione um cabeçalho expires

Sempre usar bem os cabeçalhos expires dos pacotes, para que o browser possa controlar de maneira correta o cache. Utilizando expires para datas futuras você cosegue um ótimo ganho de performance, por que não vai ser necessária outra chamada HTTP, pois o browser vai saber que seu cache não expirou e vai manter os arquivos já baixados.

Obviamente isso deve ser bem controlado para você saber o que deve ficar no cache e quando substituir determinadas coisas (que podem ser substituidas alterando o nome, por exemplo).

Componentes gzip

Sempre usar o mod de gzip (se vc estiver usando apache), pois os ganhos são muito grandes, e chegam a mais de 50% do total de tempo final de renderização da página. #### Coloque as folhas de estilo no topo Um argumento bem legal para esse! O autor do livro mostrou suas experiências com o arquivo CSS em outros lugares que não são o topo e percebeu que a página esperava pelo CSS para poder continuar renderizando a página, portanto reduz a experiência do usuário, que ficará com uma página em branco enquanto aguarda, sendo que poderia estar vendo aos poucos a página.

O que faz o browser esperar que o CSS seja carregado é o fato de ele não ter que renderizar duas vezes (uma com o css padrão do browser e outra com o seu CSS personalizado).

Coloque os scripts no final

O argumento para esse é que a pagina sempre para de carregar os outros componentes enquanto está carregando os scripts, por que eles podem alterar a página com algum document.write, e muitas a ordem precisa ser mantida, portanto com os scripts no final da página você vai retardar menos o carregamento, pois quando estiver carregando o script o usuário já vai ter uma boa parte da página para se intreter.

Lembrando que nem sempre é possível colocar o script no final da página, pois as vezes os elementos precisam do script carregado para fazer determinadas coisas, mas sempre que possível a sua performance pode ser melhorada com os scripts no final.

Exite expressões CSS

Todos sabemos que expressões CSS ( usando expression ) não é bom, e o livro demonstra alguns por que's disso que não vou abordar, apenas digo: Não use!

Deixe o Javascript e o CSS em arquivos externos

Interessante essa parte, por que como eu pensava, realmente deixar o CSS e o Javascript embutidos na página é mais rápido, mas quando se tem Javascript e CSS em arquivos separados e com um expires configurado você tem uma melhor resposta por que os scripts seriam carregados uma vez só e depois mantidos em cache enquanto várias páginas ficariam menores para carregamento.

Reduza as pesquisas em DNS

Nesse capítulo ele fala um pouco do tempo que demora para resolver um DNS e que é possível fazer caches de DNS

Minimize o Javascript

É comentado um pouco de ofuscamento de Javascript, quando você tira todos os espaços e caracteres inúteis do seu javascript deixando ele funcional e mais leve. Quando se usa Gzip essa técnica ajuda pouco, pois o texto já vai ser compactado, mas mesmo assim ainda há ganho, e um comentário pessoal: Se você não altera esse javascript com frequência, por que não? :)

Evite redirecionamentos

Os redirecionamentos são reponsáveis por uma boa parte do tempo de uma requisição, deixando o usuário vendo uma tela em braco nesse meio tempo, portanto não são nada bons para um website. O livro trata de algumas formas para evitar redirecionamentos, como alias do apache por exemplo.

Remova scripts duplicados

Parece estranho a primeira vista mas realmente acontece dependendo do tamanho do seu código e a quantidade de CSS e Javascript que você possui em sua página. O autor resolveu colocar esse tópico analizando grandes sites da internet e percebendo que vários deles possuia esse problema, gerando requisições em vão.

Configure as Etags

Use-as ou deixe-as! As Etags podem ajudar bastante na performance se bem configuradas e o livro dá vários exemplos de como isso pode ser feito, alem de uma explicação legal do que são as Etags.

Faça com que o AJAX se aproveite do cache

O livro descreve alguns exemplos onde o cache pode ser utilizado para aplicações com AJAX (utilizando expires com data futura) e outros onde realmente é dinâmica demais para se usar um cache. É interessante para se descobrir maneiras diferentes de se lidar com a performance e como ela se aplica para o seu caso.

Analizando 10 grandes sites

Essa foi uma parte que eu gostei bastante de ler, por que ele mostra grandes sites que estamos acostumados acessar ( os sites analisados nesse capítulo são: Amazon, AOL, CNN, eBay, Google, MSN, MySpace, Wikipedia, Yahoo, Youtube ) e mostra as partes boas e ruim que foram implementadas, e assim você ve com ótimos exemplos o que poderia ser feito, juntamente com as ferramentas utilizadas para a medição de cada uma das funcionalidades, e você pode muito bem utilizar as mesmas ferramentas para medir o seu website.

Conclusão

O livro é muito legal para se saber como trabalhar bem uma performance de front para você proporcionar uma melhor experiência para o seu usuário, deixando uma navegação mais rápida. Algumas das coisas que o livro aborda são extremas (necessárias para grandes sites, como no caso do autor, o Yahoo!), e muito provavelmente não são totalmente úteis em pequenos websites, mas a grande maioria é totalmente aplicável.

Eu particularmente gostei bastante do livro, mesmo ainda não aplicacando tudo o que o livro fala, consegui ter uma boa noção de boas práticas e experiências de alguem que já trabalhou com isso e tem bons argumentos para lhe dizer por que isso seria uma boa escolha.

Eu recomendo! :)

Instalando gems do GitHub manualmente

Unknown — Tue, 28 Jul 2009 00:00:00 +0000

Esse vai ser um post rápido para relatar um problema que eu tive ( e ainda estou tendo ) para instalar gems do GitHub.

Por algum motivo bizarro (nem tanto assim, parece ser dns, mas já tentei opendns e nada) a página http://gems.github.com não abre de maneira nenhuma, enquanto a navegação continua normal sem nenhum problema... A consequência disso é que eu não consigo colocar o source do github nas minhas configurações do Rubygems. :(

Tendo em vista que eu não conseguiria utilizar gem install para nenhuma gem que vinha do GitHub tive que dar um jeito de instalar manualmente. :)

O que fiz foi acessar a página do GitHub referente a gem que eu queria instalar, que no caso é a kitabu do fnando, pegar o link de clone e clonar:

$ git clone git://github.com/fnando/kitabu.git

Mas ae que está o lance que eu demorei para encontrar (noob), para uma gem ser instalada localmente ela precisa estar empacotada, e no GitHub você baixa direto o código fonte. Para empacotar:

$ gem build kitabu.gemspec

Agora sim eu tenho o arquivo kitabu-0.3.3.gem que eu posso utilizar para instalar localmente! Para instalar é só utilizar o gem install padrão informando o arquivo a ser instalado:

$ gem install kitabu-0.3.3.gem

E pronto! Lá está a minha gem instalada!

Espero que isso seja útil para mais alguem que precise empacotar as suas gems. :)

Encontro de numero 5 do Guru-sp

Unknown — Tue, 21 Jul 2009 00:00:00 +0000

Nesse sábado aconteceu o quinto encontro do Guru-sp! :)

O encontro estava marcado para as 10 da manhã com uma seção para iniciantes e começou as 10:30 ( sempre atrasa um pouquinho né? hehe ), já com um bate papo legal coordenado pelo @rafaelrosafu após uma breve apresentação de todos os participantes.

Rails para iniciantes

Nessa primeira seção tiveram muitas conversas interessantes sobre algumas filosofias Rails, como:

DRY
REST
TDD
Test all the Fucking Time
Skynny Controllers and Fat Models

e mais algumas outras coisas bem interessantes que fomentaram uma ótima discussão sobre quais os melhores padrões para se seguir quando se constrói uma aplicação Rails (sim, falamos tomando como base uma aplicação Rails), como utilizar plugins como o ResourceController (que tem seus prós e contras), manter seus scripts num lugar diferente da pasta scripts, que é a pasta padrão para scripts "internos" do Rails e tentar centralizar em uma pasta dentro de lib, além de usar Rake sempre que possível para essas tarefas ficarem organizadas e de fácil acesso.

Uma parada rápida para o almoço no Shopping e lá se vão mais de 20 programadores para comer a bater papo! :)

DataMapper

Após o almoço tivemos a palestra sobre DataMapper do @rafaelrosafu (olha ele aí novamente!) que explicou muito bem dando várias referências sobre o seu blog pessoal e como ele fez para utilizar o DataMapper ao invés do Active Record. O Rails é mais difícil de se sair do padrão, mas ficará mais simples de se escolher um ORM quando chegarmos ao Rails 3. Aproveitando o gancho de DataMapper eu falei um pouco de Sinatra dando alguns pitacos na condução do Rafael.

Git

Após a palestra de DataMapper passamos para uma palestra de Git com o Douglas (qmx), que foi muito interessante e participativa! Pegamos uma galera do grupo para fazer um scaffold e commitar no projeto para começar a ver coisas diferentes, como merges, rebases, mudanças de commit, e algumas outras coisas legais, como usar tags, procurar por um código em meio aos commits e outras coisas interessantes! =)

Levantamos a idéia de participar do Rails Rumble, aproveitando que o Diego Carrion estava conosco e comentou que a GoNow estava patrocinando 3 equipes para o evento, mas não conseguimos ter uma idéia legal para propor para o concurso.

Coding Dojo

E finalmente como ultima coisa do dia tivemos o nosso coding dojo, que era uma das coisas que eu mais estava esperando nesse econtro! O Vinicius Baggio "se ofereceu" (com um empurrãozinho meu...hahah) para ficar com o notebook ligado no datashow e conduzir o código. O dojo foi muito divertido com participação de todos da sala, o que sempre trazia novas idéias para fazer um código melhor e agregava conhecimento para todos. Fizemos TDD para construir umas classes simples de usuário. :)

Conclusão

Gostaria de agradecer ao André e o pessoal da Voice Technology por todo o apoio ao evento e ao grupo, com local, organização, fotos e mais várias outras coisas! Guys you Rock! :D

Infelizmente algumas pessoas não puderam aparecer, e outras apareceram por pouco tempo (o Marcelo Castellani), por motivos pessoais, mas espero que estejam presentes no próximo! :)

O evento realmente valeu a pena e aprendi muita coisa por lá, alem de conhecer muita gente interessante tambem! Agora é marcar os próximos e esperar que o grupo cada vez cresça mais e podemos fortalecer as amizades e conhecimentos!

Pragmatic version control using Git

Unknown — Sun, 19 Jul 2009 00:00:00 +0000

Há tempos que eu estava querendo conhecer um pouco mais do Git e nos últimos dias estava procurando um livro legal, quando me deparei com esse livro. Fiz algumas perguntas para um pessoal no Twitter como pessoalmente sobre esse livro, alguns me recomendavam, outros me passavam outros também interessantes, e estava em dúvida entre comprar ou não, até que consegui emprestado e li em 3 dias.

O livro é bem interessante, aborda desde o mais básico até o nível intermediário, não abordando conteúdos tão avançados.

Começa abordando como é o fluxo de trabalho do git, mostrando com exemplos práticos como você faz para usar o git num projeto, modificando o arquivo, adicionando para o stage, fazendo commits e etc. E fica uma boa parte do livro mostrando um pouco sobre as formas com que você pode fazer as coisas, como:

Adicionar arquivos como o git add -i para adicionar interativamente
Usar git log -p para alem de ver as mensagens de commit ver tambem o que foi usado
git log -2 para ver apenas as 2 ultimas mensagens de log
git diff --cached para fazer o diff do que já está no stage
E mais várias outras dicas úteis

Uma das coisas que eu achei interessante foi a apresentação de curiosidades interessantes como dizer que o Git usa um hash SHA1 que tem uma chance se se repetir de 2⁶⁹ :P.

Comentou sobre algumas ferramentas para se usar junto com o Git, como alguns mergetools para facilitar no processo de merge e o git gui ( que é feio que dói, mas funciona ) para quem gosta de brincar com algo no estilo tortoise.

Depois de explicar sobre a parte básica do Git ele começa a passar para algo mais intermediário, onde vem os merges e as modificações de commits localmente.

Nessa parte mais intermediária foi comentado sobre o git rebase e como você pode usá-lo para reorganizar os seus ultimos commits usando git rebase -i. É uma técnica bem interessante quando se faz um monte de commits locais mas quer enviar apenas um commit para o repositório.

Foi comentado tambem sobre tags e como é útil utilizá-las para marcar as versões do seu sistema, sendo que você pode adicionar commits apenas a uma tag e tal. Utilizando git tag 1.0 você já define que determinado commit marca a versão 1.0 do seu sistema. Você pode depois dar um git checkout na sua tag e ver ela como read-only (sendo possível criar um branch e fazer modificações).

Mais modos do git log foram apresentados tambem, como fazer um git log para ver os commits das ultimas 5 horas, ou desde as 10 horas usando --since ou --before, ou até mesmo usar um --pretty=format:"" e passar uma melhor maneira para formatar o seu log. :)

Conheci algums comandos interessantes que raramente são usados mas são muito úteis tambem:

O git gc que compacta o seu repositório para que ele exclua tudo o que não está relacionado a nada, assim reduzindo o espaço que seu repositório ocupa.
O git archive para você gerar um arquivo com seu repositório com a versão que quiser, sendo tag, passando o Head ou o que achar melhor.
O git reflog para quando você precisa recuperar algum commit que não está mais no repositório, algo que estava em um branch que foi excluído ou coisas do gênero ( lembrando que se você usou o git gc isso não será possível )

O livro tambem comenta de vários outros comandos, como o git cherry-pick por exemplo, para você passar um commit para outro branch, e sem contar que mostra várias opções que os comandos normais tem, como o git diff para você ver os status a partir de uma tag e tal.

Concluindo, achei o livro interessante e recomendaria para muita gente! O que eu tenho a dizer é que ele não é um livro para alguem que quer ver algo avançado em git, e sim alguem que não conhece ou sabe apenas o bem básico, pois assim vai conhecer algumas coisas bem legais.

Como desabilitar o beep no Ubuntu

Unknown — Thu, 09 Jul 2009 00:00:00 +0000

Resolvi postar sobre isso por que é uma coisa tão simples mas irrita muito quando você não sabe como desabilitar, e sempre que eu procurava eu caia em fóruns com vários comandos bizarros e colocar algo referente ao com no blacklist e não sei o que mais lá que era chato de se fazer, quando é tão fácil.

O que sempre acontecia é que eu estava aqui ouvindo boa musica (e alta, por sinal) e programando, o que me levava ao terminal em vários momentos, e quando eu menos espero aquele meu backspace adicional gera um beep monstruoso que dá um grande susto, e isso me irritava profundamente.

O caso acima é o caso primário de beep, quando o mesmo é vindo das caixinhas de som, e pode ser desabilitado no mesmo local que o caso secundário.

O caso secundário é quando o beep chato vem do seu speaker, portanto mesmo abaixando o som da caixinha você ainda tem o maldito beep lá no speaker.

Pois bem, ambos os beeps podem ser desabilitados aqui:

System > Preferences > Sound

Todas as opções referente aos sons emitidos pelo sistema operacional ficam aí e você pode desabilitar só alguns ou todos (como é o meu caso). E para o beep do speaker é só desmarcar a caixa System Beep! :)

Espero que mais ninguém fique desgraçando o sistema por que ele fica emitindo beeps supostamente benéficos para vc! :P

Opera Unite

Unknown — Tue, 16 Jun 2009 00:00:00 +0000

Hoje é o dia em que o pessoal da Opera falou que iria reinventar a web, e o que eles fizeram foi lancar o Opera Unite!

A idéia do Opera Unite é tornar a internet mais interligada, fazendo com que você consiga compartilhar arquivos, conversar com amigos e outras coisas apenas usando o browser.

Eu nunca utilizei Opera ( não por que eu sou contra, e sim por que eu nunca precisei e sempre estive confortável com o Firefox, principalmente para desenvolver ), mas achei interessante a campanha de marketing e a idéia deles com esse novo produto. Muitos disseram que isso não era reinventar a web ( realmente fo um pouco de exagero de marketing...hehe ), mas eu acho que isso pode revolucionar muita coisa, só pela nova idéia mesmo! Quem sabe daqui a pouco tempo tenhamos nossos browsers participando bem mais da web.

O que o Opera Unite traz

Fridge - Adicionar notas no estilo Post Its
Media player - Para compartilhar suas musicas, você apenas ativa ele no Opera e ele abre uma página compartilhada onde você pode apenas clicar e ouvir! =)
Web Server - Para compartilhar páginas HTML! É possível criar um index.html e compartilhar ele, assim você terá uma página sendo que seu computador será a hospedagem.
Photo Sharing - Para compartilhar os seus albuns de foto.
The Lounge - Ferramenta para hosting de um chat, bem interessante por sinal.
File Sharing - Para compartilhamento de arquivos ( obviamente )

Todos os serviços são protegidos por senha assim que são disponibilizados para manter a sua privacidade, mas você pode deixar publico se quiser. Os serviços tambem vem desabilitados por default quando você instala o Opera, mas é facil habilitar:

Após instalar o Opera você verá no canto inferior esquerdo um ícone parecido com um ventilador, após clicar nele você verá um assistente para criar uma conta no Opera.com e habilitar os serviços no Unite ( é simples ).

Considerações finais

Eu gostei bastante da ideia do pessoal do Opera, e acho que traz bastante interatividade para a internet. Talvez aqui no Brasil ainda não seja uma realidade um compartilhamento entre computadores bom usando a internet devido as nossas conexões, que na maioria das vezes não é rápida o suficiente para dar uma boa impressão para o serviço.

Parabéns a equipe do Opera pela inovação! :)

Instalando modem 3G Claro USB E226 no Ubuntu

Unknown — Sat, 13 Jun 2009 00:00:00 +0000

Após receber um modem Claro da empresa que eu trabalho atualmente eu fui fazer o processo de instalação no Ubuntu. Já tinha recebido a informação de um colega de trabalho de como fazer, e obviamente não foi nada difícil (o que que é difícil no Ubuntu? :)).

Vou descrever aqui o processo:

Inserir o modem na entrada USB
Vai aparecer um assistente de configuração simples ( Next Next Finish ), para você seguir e instalar.

Caso o assistente não apareça automáticamente (foi o meu caso), você pode acessá-lo clicando com o botão direito em cima do ícone de rede que fica ao lado do relógio e clicar em "Edit Connections" ou apertar Alt+F2 (ou o seu atalho para executar) e digitar nm-connection-editor.

Estando no editor de conexões basta clicar na aba "Mobile Broadband" e depois clicar em "Add", que o assistente vai aparecer.

Quando terminar o processo com o assistente ( rapidinho ) o seu modem já estará instalado! :D

Para sua internet funcionar você só vai precisar mudar os endereços de DNS que não estarão corretos. Para alterar apenas clique em na conexão que você criou no "Edit Connections > Mobile Broadband", e clique em "Edit".

Após clicar em "Edit" digite a senha do seu usuário (se necessário) e siga para a aba IPV4 Settings. Nessa aba altere o campo DNS Settings para 208.67.222.222, 208.67.220.220.

Com isso você já vai conseguir navegar normalmente! :)

Serviços interessantes

Unknown — Fri, 12 Jun 2009 00:00:00 +0000

Depois de conhecer alguns serviços legais na internet resolvi postar sobre eles aqui. Gostaria de fazer um post desse tipo mensalmente ( assim como o Ronaldo Ferraz faz no seu blog sobre o balanço cultural, que eu acho bem legal ), mas pelo menos dessa vez quero postar algumas coisas legais, e se possível eu posto periódicamente o que eu tenho feito / encontrado de divertido. ;)

Dropbox

Já começando com o DropBox, que é uma aplicação para sincronização de arquivos. Ele funciona da seguinte maneira:

Você instala o software do dropbox (que tem para várias plataformas! ), e cria uma conta no site, com isso eles disponibilizam um armazenamento de 2GB gratuitamente para seus arquivos (e mais no máximo 3 GB se você recomendar alguem, portanto se for criar me peçam um convite please).

Com o Dropbox você pode criar pastas compartilhadas com seus amigos que tambem possuem dropbox, assim compartilhando arquivos facilmente, só colocar ele na pasta que o dropbox vai fazer o upload automáticamente e o dropbox do seu amigo vai receber automáticamente tambem.

Eu estou usando o Dropbox para compartilhar arquivos de estudos com uns amigos e tambem para sincronizar o meu arquivo do notecase entre o trabalho e minha casa ( assim não preciso ficar colocando pendrive toda vez que for usar o notecase ).

Shelfari

O shelfari é uma rede social para leitores de livros! Lá você pode compartilhar suas leituras com os amigos, dizendo o que está lendo, o que planeja ler, o que já leu, fazer resenhas de livros, comentários e mais um monte de coisas legais.

Gostei bastante da forma que ele organiza os livros, e o layout de prateleiras é bem legal tambem. Descobri que eles tem um Widget que adiciona uma prateleira ( bonitinha! ) no seu blog / site e é totalmente customizável! Gostei! Vou colocar no aqui assim que eu der uma arrumada no layout do blog.

Comunidade Software Livre

Apesar de não gostar muito de redes sociais (para mim fica tudo como redes anti-sociais) eu achei legal a iniciativa de uma rede social para software livre! Seria legal se a grande massa da comunidade estivesse por lá! :)

Não tem muito o que comentar pois é uma rede social comum como todas as outras, mas essa tem um foco diferente, que é juntar o pessoal de software livre em um só lugar. ;)

É isso! Esses são os 3 serviços que eu achei interessante e gostaria de compartilhar, espero que seja útil para os leitores do blog.

Organizando seu Gmail para manter Inbox zero

Unknown — Wed, 20 May 2009 00:00:00 +0000

Agora chegando em tempo de provas e grande acumulo de atividades no trabalho eu fico começando a procurar as brechas de tempo que eu gasto "inútilmente" para ver se eu consigo aplicar em alguma coisa que possa me ajudar a cumprir todas as tarefas. Fiz uma pequena análise do tempo que eu perdia em determinados lugares, e vi que tanto e-mail como Twitter me consumiam uma grande quantidade de tempo ( com o Twitter é fácil, só desativar temporariamente e seguir menos gente ), portanto decidi fazer um refactoring! :)

Eu uso o conceito de Inbox zero, ou seja, não deixo e-mails pendentes na minha caixa de entrada, mesmo que eu tenha que tratá-los de modos diferentes, portanto eu sempre estou olhando a minha caixa de entrada e me incomoda bastante saber que tenho coisas pendentes lá ( mesmo que seja só para ler ).

Depois de contar um pouco do drama, vamos ao refactoring! ;)

Listas de discussão

Atualmente eu assino quase 15 listas de discussão, sendo que sou moderador na gtd-br ( sobre organização pessoal com o método Getting Things Done do David Allen ) e em mais 2 listas ( Faculdade e amigos do curso técnico ). Várias dessas listas são ativas e enviam cerca de 3 ( ou mais depentendo da lista ) e-mails por dia, portanto eu tinha cerca de 30 e-mails por dia somente de listas de discussão, fora os e-mails que eu recebia externamente.

Uma das medidas que eu sabia que ia me ajudar bastante a manter a organização da minha caixa de entrada e poupar bastante do meu tempo era sair de várias listas que eu participava mas nem acompanhava e colocar todas as que sobrarem como Digest, e foi isso que eu fiz! :D

Organizando as labels

Tinha uma grande quantidade de labels que eu não estava usando, ou que criei para uma determinada finalidade e agora não estavam servindo mais para nada, portanto comecei a ver o que me servia e o que não servia para reduzir um pouco o que eu devia organizar.

Após retirar as labels que estavam sobrando ( mais ou menos umas 10 ), comecei a incluir alguns prefixos para poder categorizá-las para melhor visualização. Utilizei os seguintes prefixos:

[Fr] - Projetos freela que eu participei / participo
[Gr] - Listas de discussão ( Groups )
[Ps] - E-mails pessoais que eu gosto de Rotular
[Wk] - E-mails referente ao trabalho que as vezes preciso receber aqui

Utilizando esses prefixos nos meus labels eu consegui organizar minhas coisas por tema, assim vendo facilmente o que eu tenho de pendências.

Organizando os filtros

Agora com as minhas labels arrumadas, preciso gerenciar os e-mails que estão vindo, e para isso eu uso os filtros do Gmail, que encaminham automaticamente os e-mails para suas determinadas labels, já arquivando e fazendo outras coisas.

Primeiro criei filtros para as listas de discussão ( que agora vem em formato Digest ) para arquivar diretamente, colocar na label do assunto correspondente e marcar com estrela. A idéia de marcar com estrela foi para resolver um problema que eu tinha antes, que era ter que ficar passeando em todas as labels olhando digest por digest / email por e-mail, e agora como tenho todos os e-mails de digest com estrela, eu posso ler todos de uma vez só e apenas ir retirando a estrela, e ele já estará arquivado, lido e guardado em sua devida label! :)

Criei filtros também para os e-mais que eu recebo de fóruns e newsletters para que eu possa ler apenas quando for possível, sem que eles precisem ficar alí me incomodando em tempo integral.

Com essa organização eu pude controlar melhor tempo, sendo que todos os dias quando chego no trabalho tenho os vários Digests das listas de discussão que acompanho para ler, mas o processo é rápido e fácil, sendo que vejo apenas os tópicos que me interessam ( baseado no assunto ), e consigo olhar entre todos facilmente, já deixando organizado. Agora sei que posso continuar com a minha caixa de entrada aberta o dia inteiro para enviar e-mails repentinos, sem que isso me tome tanto tempo.

Se alguem tiver mais dicas poste nos comentários.

Usando Git em projetos do Google Code

Unknown — Mon, 11 May 2009 00:00:00 +0000

Resolvi escrever esse post depois de começar a contribuir para o projeto do vimbook, que está no Google Code.

Como o Google Code só usa Subversion (infelizmente) e eu sou do mundo Git, resolvi usar a ferramenta Git para lidar com SVN, o git-svn! Com ele você pode clonar um repositório SVN e utilizar como Git, e na hora de "commitar" ele retransforma em SVN.

Já havia tentado usar Git-svn no meu projeto de plugin para wordpress, mas nesse caso eu já tinha um repositório Git e fui tentar mandar para um repositório SVN vazio, o que só me deu dor de cabeça, e no fim das contas acabei jogando para um repositório SVN qualquer só para mandar para o Wordpress. No fim das contas, depois desse problema com o Wordpress eu só tinha abominado o git-svn, mas agora eu estou começando a descobrir o seu valor.

Meus agradecimentos ao Carlan Calazans que me deu umas dicas de Git-svn quando eu comecei a tentar usar no projeto do plugin, que naquele momento não me fora de grande serventia, mas depois ajudaram bastante! ;)

Bem, agora chega de papo-furado e vamos a parte que interessa...Códigos e How To! :)

Primeiramente vamos baixar o código ( estou usando como exemplo o vimbook ):

git-svn clone https://vimbook.googlecode.com/svn/trunk/ vimbook --username seu.usuario.do.google

Ao digitar isso ele vai pedir uma senha que ele gera para a sua conta, e seus commits ficarão ligados a sua conta do Google. Para obter a sua senha é só acessar a página de settings do google code com a sua conta.

Após digitar a sua senha ele vai começar a receber todos os commits do SVN e converter para Git! O processo pode ser um pouco demorado, dependendo do tamanho do repositório SVN que você está importando.

Quando terminar você terá um repositório Git normal funcionando, e você pode trabalhar normalmente com ele, fazendo seus branchs e tudo mais! :D

Vamos ver como seria um fluxo simples para você fazer uma alteração usando branch e mandar de volta para o repositório:

git checkout -b new_changes

Branch criado! Faça as suas alterações...

Após as alteraçoes feitas faça os commits normalmente como se faz no Git e volte ao master para ver o que há de novo no repositório central:

git checkout master
git-svn rebase

Com isso ele vai receber as novas alterações do repositório!

Agora é a hora de fazer um merge do seu branch com a ultima versão do master:

git merge new_changes

Se tiver algum conflito resolva-os normalmente e agora é hora de enviar as suas alterações novamente ao Google Code:

git-svn dcommit

Pronto! Você está contribuindo para um projeto do Google Code utilizando Git. :D

Configurando seu Gtalk do Google Apps no Pidgin

Unknown — Sat, 09 May 2009 00:00:00 +0000

Resolvi postar sobre isso depois de passar por 3 empresas que usam o Google Apps for your Domain e eu sempre esbarrar com o maldito probleminha ao se configurar o Pidgin.

Pensei que isso era burrice minha de não ver a configuração correta, mas depois percebi que não era só eu que não via essas configurações para poder fazer o negócio funcionar! Como eu nunca anotava o processo, sempre tinha que ficar pesquisando para ver se achava algo relacionado a isso, e nunca funcionava.

Quando se pesquisa no Google sobre configurar o Pidgin para usar o IM do seu Google Apps, você geralmente cai nessa página, onde está errado...

As configurações corretas para se usar são as seguintes:

    Aba "Basic":
    Protocol: XMPP
    Username: SeuUsuario
    Domain: sua_empresa.com.br
    Resource: gmail.com/ ( não sei se é realmente necessário )
    Password: ******

    Aba "Advanced"
    Connect port: 5222
    Connect server: talk.google.com
    File transfer proxies: proxy.jabber.org

E com isso você já vai ter o seu Pidgin funcionando com a sua conta do Google Apps! :)

Ubuntu 9.04

Unknown — Wed, 06 May 2009 00:00:00 +0000

Hoje estou aqui para falar um pouco sobre o Ubuntu 9.04! :)

Alguns dias atrás eu postei no twitter que não estava satisfeito com o Ubuntu 9.04, e abaixo descrevo alguns dos motivos.

Primeiramente comecei tentando instalar ele pelo cd (para não ter que deixar o computador ligado mil horas baixando, e tambem por que tenho mais de 1 Ubuntu em casa, portanto mais de mil horas x 2) e não consegui.... Procurei várias informações, desabilitei os sources e deixei só o cd lá, e vários outros procedimentos, mas mesmo assim não tive sucesso, e por isso tive que deixar o notebook ligado fazendo download a noite inteira.

Ao terminar a instalação e reiniciar ele funcionou beleza! :)

Começando a brincar mais com o bichinho, eu descobri que o meu flash tinha bugado (para variar...), e as coisas que utilizavam ele estavam funcionando meia boca, sem contar que ainda tinha alguma coisa bizarra que funcionava como um flashblock, só que pior, por que quando eu clicava ele poderia funcioanar, ou não. ¬¬

Tentei relevar isso, mas quando fui fazer uns testes com o compiz, percebi que ele tambem não conseguia mais ativar os efeitos (tudo bem que eu nem uso... Mas gostaria que funcionasse pelo menos :P), retornando uma mensagem de que os efeitos não poderiam ser habilitados. :(

Estava meio sem tempo para perquisar sobre isso, então ficou assim por alguns dias, o que me deu um pouco de desânimo, e foi aí que postei no twitter aquele comentário.

Ontem eu resolvi tirar um tempinho para resolver esses problemas, e até que foi simples (como de costume)! ;)

Resolvendo problema do Flash no Ubuntu 9.04:

Eu percebi que estava usando um plugin free do flash, e vi comentários na internet que esse plugin não é tão bom como o da Adobe (mas funcionava muito bem no 8.10 :P), portanto resolvi desinstalar e instalar da Adobe:

sudo apt-get remove --purge swfdec-mozilla swfdec-gnome mozilla-plugin-gnash gnash
sudo apt-get install flashplugin-nonfree

E o flash já voltou a operar normalmente! :)

OBS: Se não conseguir resolver com o mesmo procedimento que eu usei, veja se consegue com um dos outros 3 procedimentos que tem no UbuntuGeek.

Resolvendo problema do compiz no Ubuntu 9.04:

Pesquisando mais sobre o meu problema eu achei esse bug no LaunchPad, com várias pessoas com o mesmo problema, e em um dos ultimos comentários tem uma dica que resolveu o meu! :)

A minha placa de vídeo estava na blacklist do compiz, e eu comentei o arquivo, deixando com que ela não fique mais blacklisted:

Abri o arquivo do compiz (que está em /usr/bin/compiz), comentei as linhas referente a minha placa de vídeo, salvei e reiniciei.

Depois de logar fui testar o compiz, e lá estava ele funcionando novamente! :D

É claro que eu já desabilitei os efeitos denovo por que não acho legal ficar trabalhando com eles, mas já está lá funcioanndo para fazer gracinhas! :P

Espero que seja útil para mais alguém.

Encontro de Design e Tecnologia Digital

Unknown — Sun, 26 Apr 2009 00:00:00 +0000

Participei nesse sábado do EDTED (Encontro de Design e Tecnologia Digital), e vou postar as minhas impressões sobre o evento, focando as palestras que assisti:

CMS’s livres: não reinventado a roda no desenvolvimento web

A palestra foi conduzida por Paulino Michelazzo da Fábrica Livre, e foi uma palestra interessante!

O palestrante soube levar bem a palestra, com momentos engraçados ( várias brincadeiras com Java e Windows, que obviamente não devem ser levadas a sério ), e apresentando como é fácil criar uma loja virtual utilizando o Joomla. O que achei legal da palestra foi ele não focar apenas o Joomla, e sim izer que você não precisa reinventar a roda, e pode usar várias ferramentas para isso como o Drupal, Wordpress, e obviamente o Joomla, cada um para sua determinada finalidade.

Crédito para o palestrante: Falou que uma parte do valor que eles conseguem com os projetos eles doam para os softwares livres que eles usam, e isso sim é devolver o que você conseguiu gratuitamente! Parabens a Fabrica Livre.

Scrum

Encontrei um amigos como o Ricardo (Guitarrista do Megadriver e programador Web ) e fiquei "networkeando" (ou conversando) por um bom tempo sobre diversas coisas, portanto acabei chegando na metade da palestra.

A palestra foi conduzida por Fabiano Milani, em nome da Caelum, e pelo que consegui assistir foi aquele overview geral sobre o Scrum (que eu tambem já tinha visto), e teve uma parte de dúvidas bem legal, com várias pessoas perguntando como poderia implementar Scrum, ou se estava implementando Scrum corretamente, com boas respostas do palestrante.

Para quem nunca tinha visto uma palestra de Scrum deve ter gostado bastante da palestra. :)

SEO - Search Engine Optimization

Tambem já tinha assistido outras pelestras sobre esse tema, e elas geralmente são iguais, portanto para mim não teve muita novidade. De modo geral, o palestrante Fabio Ricotta da Mestre SEO conduziu bem a palestra, deu dicas interessantes sobre como organizar a sua página semanticamente, mostrou várias ferramentas úteis para utilização em SEO, e várias outras dicas bem interessantes.

Uma coisa legal para enfatizar: SEO não é algo que você faz e pronto, e sim algo que deve ser mantido e atualizado com o tempo, pois você não vai ter sempre alta relevância se você aplicou SEO e ficou bem nas buscas, pois isso vai caindo com o tempo, e você precisa continuar mantendo isso com boa semântica.

Desenvolvimento web ágil: ferramentas, arquiteturas e princípios

O Guilherme Chapiewski falou sobre muita coisa legal, avaliando linguagens e frameworks como Python / Django. Ruby / Rails, Java, PHP / CakePHPe mais outras coisas. Foi abordado alguns gostos pessoais e experiência própria do Chapiewski sobre as linguagems e frameworks, inclusive algumas considerações sobre Rails e Scala (¬¬), mas a abordagem disso foi com dicas de como poderia ser resolvido de meios diferentes, com problemas que são conhecidos e poderiam ser tratados para ajudar.

Ele comentou de 7 métodos que ele usa como um programador ágil:

Soluções a longo prazo
Sempre pensar no que pode acontecer futuramente. Ele usou um exemplo bem legal sobre um cara que não documentou um sistema por que não tinha tempo, quando futuramente 3 pessoas perderam cada uma 2 dias para entender o que aquilo fazia...Ou seja no fim das contas foi perdido mais tempo do que ganhado nesse caso.
Elimine desperdícios
Usar um framework que cria tudo facilmente e você pode portar ele facilmente para outras features
Qualidade não é negociável
Aqui outro bom exemplo...O médico está limpando o paciente após uma cirurgia e o paciente fala para ele deixar isso por que está atrasado para alguma coisa, e é claro que o médico vai te ignorar e limpar, por que ele sabe o que é o certo para se fazer, ele não negociaria a qualidade do trabalho por causa do seu tempo.
Não esconda os problemas do cliente
O cliente é um cara legal e sua solição simplista pode ser o suficiente para ele
Use a melhor ferramenta para cada problema
E lá vamos com bons exemplo: Um marceneiro não usaria um martelo para cortar uma mesa sendo que ele poderia usar uma serra para isso. Portanto use sempre o mais adequado para cada situação
Documente menos e simplifique mais
Foi mostrado um bom exemplo de código, que você olhava e intuitivamente sabia o que ele fazia.
Reflita sempre sobre o que você faz e melhore comtinuamente
Não fique apertando parafuso para sempre, sempre renove seus conhecimentos.

Os argumentos do Chapiewski sobre Java ser o novo COBOL é bem interessante! Ele diz que o JAVA antigamente tinha ótimos motivos para ser adotado, e assim muitas empresas começaram a utilizar, e atualmente temos sistemas monstros desenvolvidos e vários programadores programando em Java, portanto para sair da linguagem não vai ser tão fácil assim, e foi isso que aconteceu com o COBOL. O Chapiewski falou que só usa Java hoje em dia se tiver um sistema que é obrigado a integrar com Java, por que ele não ve um bom motivo para usar Java, sendo que ele pode usar coisas que ele considera melhor e com mais benefícios.

The Rails Way - Como Ruby on Rails pode te tornar um programador pior

O Carlos Brando falou e muito bem sobre o Ruby! Falou muita coisa que eu tinha vontade de dizer sobre Ruby != Rails utilizando um exemplo de miojo e macarronada, como seu o miojo fosse o framework para o suposto cozinheiro! :D

Vários exemplos com código para mostrar como o Ruby é parecido com a nossa lingua, e não com a lingua do computador, inclusive usando uns exemplos simplificados do Why. Teve alguns exemplos de metaprogramação para saciar a vontade de quem já conhece um pouquinho de Ruby tambem! :)

Gostei bastante da ideia da palestra e o por que de você se tornar um programador pior ( você saindo de uma outra linuguagem que você se considerava bom, para uma outra coisa que você não sabe nada ), e ainda mais mostrando os facilitadores dos frameworks que ajudam você, mas abstrai um pouco da sua felicidade em desenvolver um pouquinho mais low. :P

Mercado de trabalho em TI

Foi uma "mesa redonda" com todos os palestrantes, discutindo sobre assuntos sugeridos pelo pessoal que estava assistindo o evento. Foi discutido sobre os valores de trabalho no mercado, apoio as universidades pelo governo, scrum, software livre e outras coisas.

Considerações finais

Gostei bastante do evento, consegui conversar várias pessoas legais por lá, como o Caue Linden da HostNet, Maujor do Maujor.com.br, Hugo Borges, Rafael do Ruby Inside, Ricardo que é guitarrista da banda Megadriver (ouça por que é muito foda!), Guilherme Chapiewski, Carlos Brando e mais um monte de gente!

O Evento foi muito legal quanto a palestras e networking! Quem não foi perdeu! :D

Começando a falar de Ruby

Unknown — Mon, 13 Apr 2009 00:00:00 +0000

Se você já conhece Ruby, ignore esse post! A idéia do post é mostrar um pouco da linguagem Ruby para pessoas que não conhecem nada sobre ela.

Eu, claro, acho muito interessante que muita gente por aí ainda não conhece Ruby, mesmo com a grande popularização do Rails, e eu chego a ouvir coisas assim:

"Não é você que programa naquela linguagem esquisita?"

Cheguei a ouvir do meu "professor de algoritmo" (perdeu meu respeito):

"Gostei desse algoritmo que você fez nessa linguagem esquisita aqui"

Há muitas pessoas que já ouviram falar em algo relacionado a Ruby apenas quando leram alguma coisa na Info falando de RubyOnRails. Portanto, resolvi escrever alguns posts sobre a linguagem para passar para esse pessoal que ainda não conhece nada. Pretendo que esse seja o post introdutório de vários capítulos passando por partes interessantes da linguagem. :)

Então...Vamos falar de Ruby! :)

Ruby é uma linguagem interpretada, criada pelo japonês Yukihiro “matz” Matsumoto e liberada publicamente em 1995. Desde lá o Ruby vem aparecendo bastante no mundo de tecnologia, sendo que a partir de 2006 teve um grande boom de comentários, ainda mais com o maior aparecimento do Rails.

Uma coisa que me irrita bastante é as pessoas associarem diretamente Ruby com Rails, portanto preciso deixar isso claro...

Rails não é Ruby!

Rails é um framework para desenvolvimento web que utiliza a linguagem Ruby para o tal. O Ruby tem bem mais coisas legais do que só o Rails. ;)

Como o Ruby é uma linguagem interpretada, podemos facilmente fazer um Hello World em Ruby:

puts 'Hello World'

Isso aí! Apenas uma linha! Uma linguagem totalmente orientada a objeto e você não precisa necessáriamente criar uma classe, um método ( public static void main... ) e escrever mil comandos Hierarquicamente para escrever algo! ;)

O interessante do Ruby é que tudo é um objeto, ou seja, se você escreve o numero 10 ele já é um objeto, tendo seus próprios métodos, como por exemplo:

10.times { puts 'Vou estudar Ruby' }

No caso acima usamos um dos métodos do 10 (que é da Classe Fixnum) que é o método times, que faz um loop 10 (ou qualquer outro numero Fixnum que estivesse aqui ) vezes fazendo o que está dentro do bloco, no caso, imprimir "vou estudar Ruby". :)

No Ruby você consegue modificar métodos em tempo de execução! Uma classe que não possuía nenhum método pode possuir 10 em tempo de execução bastando que seu código os inclua lá, e isso é uma coisa muito legal!

A sintaxe da linguagem foi feita para ser simples, você tem vários métodos facilitadores, inclusive com uso de "?" ( interrogação ) para alguns métodos, como por exemplo para descobrir se a variável está não retorna nada:

variavel.nil?

Aqui temos uma pergunta explícita, que você olhando isso intuitivamente lhe vem duas respostas: Sim ou não ( nem me venha com talvez :P ),o que mostra que você olha um código Ruby e facilmente distingue muita coisa.

E tem bem mais coisas interessantes!

Tá...E por que diabos eu deveria usar Ruby

Aí que está! É aí que entram as coisas legais, como:

Rails

Agora sim você pode usar esse cara aí em cima para desenvolver aplicações bem legais usando todas as facilidades que o Ruby pode te oferecer

Shoes

Uma biblioteca bem interessante para desenvolvimento desktop multiplataforma, onde você consegue fazer muita coisa legal.

JRuby

Olha que legal, se você gosta bastante do Java, você pode rodar programas Ruby em cima da maquina virtual Java, o que é bem legal, até por que, a velocidade do JRuby, já passou a do MRI ( Matz Ruby Interpreter, ou a versão core oficial do Ruby, feita pelo Matz ).

Inclusive você pode importar várias bibliotecas do Java e tudo mais. ;)

Iron Ruby

Você usa a plataforma .NET da Microsoft? Então procure por esse cara! Eu não tenho muito a comentar por que não uso .NET.

É claro que não existem só esses aí em cima, apenas estou citando algumas coisas legais, mas se você procura por desenvolvimento web você pode escolher Sinatra, Merb (ainda não se fundiu com o Rails, mas isso vai acontecer na versão 3 do Rails), ou outros.

E se você apenas pensa em desenvolver para Desktop, alem do Shoes, você pode escolher, o RubyGTK, o MacRuby (para usuários MAC) ou até o FXRuby!

Se você não é programador, e trabalha com administração de sistemas, por que não utilizar Ruby para automatizar as tarefas? É fácil, tem manutenção simples, vem padrão em várias distribuições Linux...Não tem desculpa! :P

Meu foco nesse post não é abordar a fundo nenhuma das ferramentas que eu citei acima, e sim apenas dar um overview de tudo que você pode fazer usando essa linguagem.

Puxa, gostei! Como usar?

Moleza! Está no Linux né? Se estiver usando Ubuntu só dê os comandos mágicos:

sudo apt-get install ruby irb rdoc

Não está no Linux? Humm...No Windows é fácil tambem, baixe o executável e instale. Não tive muito contato com um mac ainda para instalar coisas e tudo mais, mas me parece fácil.

Basta clicar aqui e pegar os arquivos necessários para a instalação! :D

Vixe...Instalei, e agora?

Agora é hora de brincar um pouco com a linguagem para saber como ela funciona! Eu recomendo você a entrar no IRB (Interactive Ruby Shell) e começar a brincar!

Para acessar o irb é aquela moleza de sempre, apenas entre no terminal e chame por irb ( acho que funciona assim no Windows tambem )! :D

Lá você pode tentar executar uns códigos, inclusive os poucos exemplos que eu postei aqui, é muito legal para você conhecer a linguagem, descobrir uns métodos e tudo mais.

Já estou no IRB, mas eu não sei fazer nada...

Bem, agora é partir para as cabeças! :D

Eu recomendo você a começar lendo o tutorial de Ruby do TaQ que é um material bem legal para começar.
Se seu ingles é bom (não precisa ser fluente, mas você precisa saber ler e enteder) eu aconselho firmemente você a participar de algum curso Core do Rubylearning.org, e lá você vai aprender bastante coisa, alem de se divertir bastante.
Leia alguns dos livros gratuitos que estão disponíveis na web gratuitamente e em português! Eu recomendo o Aprenda a Programar e o (comovente) guia de Ruby do Why. ( obrigado pela dica Abraão )
Participe de Grupos de usuários para aumentar seus conhecimentos e conhecer pessoas que tambem estão interessadas na linguagem e sempre estudando! Se você está em São Paulo eu recomento fortemente você a participar do GURU-SP! :)
Fique de olho aqui no blog que eu pretendo começar a postar umas coisas básicas, mas não espere somente por mim e já inicie seus estudos! ;)

Bem, com isso você já tem uma pequena base do que é o Ruby ( e sabe que o Rails é apenas um framework feito em Ruby ) e já pode começar a se divertir com ele! :D

Plugin para WordPress: Anti IE6 Army

Unknown — Sat, 11 Apr 2009 00:00:00 +0000

Estou postando para anunciar que foi lançada a versão 1.0 do meu plugin para Wordpress chamado anti-IE6-army! :D

A idéia do plugin é juntar um exército de campanhas contra o Internet Explorer 6 que estão perdidas pela internet em um único plugin, para que todos que possuem blogs com Wordpress possam usar facilmente, sem precisal alterar HTML, ou abrir qualquer arquivo de código!

Aqui no blog tem uma página só para falar do Plugin, e lá você pode obter mais informações.

Espero o comentário de vocês sobre o Plugin, e se quiserem contribuir com código, o projeto está no GitHub! :)

Esse foi o meu Call to Arms, agora espero que vocês realmente usem! ;)

English Version

I'm posting here to announce my anti-IE6-army Wordpress Plugin! :D

The idea behind this project is unite a lot of campaigns against Internet Explorer 6 that are splitted on the internet on one single wordpress plugin, so everybody with a Wordpress blog will can use it easily, without change any HTML, or open a single code file!

You can read more about this plugin on the plugin page at this blog.

I'm waiting your comments about the plugin, and if you want to contribut with code, the project is on GitHub! :)

This post is my Call to Arms! Now i hope you really use this plugin. ;)

Translated Rubylearning presentation

Unknown — Fri, 10 Apr 2009 00:00:00 +0000

As I promised, here goes my presentation! :)

Finally i finished to translate all the presentation! Watched the video a lot of times, pausing and playing to write all I said translating to english. :)

Fortunately I had a big help from my friend Victor Goff, that corrected all my grammar errors and typos.

I'm posting below all i have about the presentation, slides from Slideshare and a translation pasted here, but you can find the translation at Google Docs too. Enjoy! :D

First Words

My name is Willian Molinari as Marcelo said, I participated of 3rd Batch of Rubylearning at the beginning of the last year. Since the finish of the course I was an Assistant Teacher, and i'm a Mentor since the beginning of this year. I attempt to show to you a bit of what Rubylearning is and how does it work, what is the course idea. It is a short presentation, you will see that I'll "run" with the content, but the presentation idea is to show you a bit of what RubyLearning courses are.

Slide1

Fist, lets start with "What is Rubylearning?" The course itself is Rubylearning.org, and Rubylearning is divided into Blog, Website and courses. Blog is where Satish post some of his interviews with Ruby community guys like Matt of Merb project or Dr. Nic. And on blog have other cool posts too. On Website Satish maintain a Ruby tutorial, a Ruby Book and post other ruby contents.

And on Rubylearning.org the course happens.

Slide2

To answer the question "What is Rubyleraning.org" I was helped by the other teachers of Rubylearning. One of the good answers was made by George Thompson, this guy that you see in the large photo. After telling a funny joke, saying that Rubylearning is for everything since it will "allow you to grow wings to fly" and will "help you in the bedroom" He gives these topics to speak about. The first thing is that Rubylearning is for everyone that has an interest in Ruby, if you are a experienced professional, or just learning now, Rubylearning is here to help you. It is a framework to your first steps with Ruby, so you will not depend just from Google or online tutorials, on Rubylearning you will have more people to help you to participate and discuss your answers and so on... Rubylearning is not just for who are starting with Ruby. If you work with Ruby for a long time, you can participate to help the students that are starting, returning to the community what you received. And you can participate with other Rubylearning intermediate courses (Rubylearning doesn't have just the Core course, we have other courses for those who already have knowledge of Ruby) And of course...Rubylearning is a place to have fun! To code for fun, to know different people of other countries, or maybe of your country, and you didn't know that this person was programming on this language.

Slide3

Rubyleraning is based on Moodle, as you can see, the image is strange here, but the first screenshot is the screen after you sign up, and you can see all the courses that you can subscribe to, and below you can see the screen inside the course, all the material is divided by blocks, the forums and so on.

Slide4

More interesting informations about Rubylearning:

We are the declared winner of shorty awards in education category. Unfortunately we couldn't participate of ceremony in USA because only Satish can participate in the ceremony, and the price to travel from India (Satish is Indian) to USA could not cover the costs...But anyway, we are the winners!

The number of participants get over 7200 mark, and maybe now we already pass the 7500 mark, because this information is from 1 month ago, more or less.

Another cool thing, more than 40% of Rubylearning participants are from Brazil, so you don't have arguments to say: "I can't participate, because the course have people that from other countries and i don't speak english very well", because always you will find a Brazillian to help you there.

Slide5

And who is the main teacher? Who is behind Rubylearning?

Slide6

Satish Talim, as I said, lives in India. He is a programmer, teacher, consultant, working on some companies at India and USA, is speaker and has more than 30 years of experience with I.T. He has these two domains: Rubylearning.org and rubylearning.com. On .org domain we have the course and on Rubylearning.com is his site. And he have a personal website domain, too.

Slide7

Ok, if Satish is behind Rubylearning, who are these guys that help on forums? So... I asked to Satish by e-mail, because I didn't know about how he divide us. The assistant teachers are people that come from the core course and enjoyed the course, so they are invited to help, and whomever accept comes as assistant teachers of the next core course to help on foruns, answering the students that are having doubts and helping on other things.

Mentors are experieced professionals that are working with I.T for a long time and more time on Rubylearning, too. They help not only on Core course, but on the other courses ( intermediate courses ) too. The Patrons, this guys are on Rubylearning since rubylearning is coming to be international, on the 2nd batch more or less, on the last months of 2007, and they have more time on rubylearning, so the way that Satish has to classify teacher is time on rubylearning.

Slide8

For who is this course appropriate? Well... Our focus is the people that already know something about programming, some other language and wants to know Ruby, and not those people that do not know how to program and want to learn on Rubylearning, This is not our focus. Our focus is to teach Ruby for who those have a notion about programming.

Slide9

How does Rubylearning work? Well...The course is slotted into weekly study material blocks. Every Saturday, Satish posts different sudy material with important notes, so you can review quickly all you already read; Some exercises, 10 or 5 exercises depending on how extensive is the material, for you to solve and post on forums, to view the answers of teachers too.

For example, you have a method and you are using return to return the variable on the PHP style for example, but can be other language, so somebody replies to you saying that you don't need to specify this return because the Ruby language returns the last statement by default, and so on... The Quiz, is for your own benefit, so you can see if you learn all the content.

And the Extras! The extras take to you some good material as links to good content, a screencast related to the weekly study material, and others!

Slide10

How do quizzes work? As i said, Quiz is for your own benefit. A lot of people are questioning me about the importance of quizzes on the course participation, "if we don't answer the quiz, are we kicked out of the course" or we don't receive the certificate. The quiz idea is auto-validation, so after you read all the content, you will know with the quiz if you really learn all you need to learn about that content, if you got a good result with the quiz, you probably really learned this weeks content.

Slide11

Is necessary be active on Foruns? Humm...Yes! The main focus of Rubylearning is the participation of everybody, so, if you really want to get the best of the course you must to post your exercise answers, to receive from more experienced people feedback about your solution. If you don't participate so much.. it's okay too...You just lost the chance to learn more and more.

Slide12

This is one of the things that everybody speaks about..."Ohhh...The course is in english, from India, i will talk nonsense words, i don't speak english, my english is bad"...Humm...My personal English, i'm a assistant teacher, is not so good, but i can communicate with others! If you can communicate with other people is good enough! You will read and understand the content and post your code on forums, if you are not comfortable to write english, you can just post your code, somebody will reply to you, you will understand the reply and it is good enough to your learning. If you can talk is really better, because you can help on discussions, but the english is not a big barrier to participate of Rubylearning.

Slide13

How is the course pace? As i said, Satish does weekly content posts on forums...Not forums...the study materials. You don't need to follow this weekly pace, if you decide to view all the course in the last week you can, but we recommend you to follow weekly because you can talk with other people that are studying the same lesson and you have more focus on your studies making it easy to learn different things.

Slide14

What topics the course cover? Well...We cover all the Beginning with Ruby, from Ruby installation through...

Slide16

basic classes like numbers, blocks, variable scopes, constants, methods, manipulation of text files, Regular Expressions, but only the basis of Regular Expressions, how to work with RE with Ruby, working with classes, inheritance, exceptions... We can't cover tests (the Ruby test/Unit class) on the core course just a bit of it, we want to create a course just to cover test/unit itself, so it is not a core part of Ruby in this course.

Slide17

Other questions that are often made to me when I recommend Rubylearning couse is: "I will receive a certificate?". The important thing on the Rubylearning course is how much you can learn with the course, the certificate is not the course focus, but...The answer is YES!

Slide18

This is my certificate from 3rd Batch that i participated, really beautiful, signed by Satish, you receive in PDF, is not received in paper, but you can print and store.

Slide19

As i said, Rubylearning is not made of only the Core course, we have a lot of other courses that we call the "Intermediate courses", and is appropriate to who that already have a notion of what is Ruby core, if you know core, you can move on to these other courses.

Slide20

The merb course, now merb team are joining Rails team, maybe this course will be extinct, but this is one of our courses for now. Git / GitHub is a course of one week. Git is not directly connected with ruby, but all the Ruby community are using it, so we decided to prepare a course about it. Ruby with database, using MySql and sqlite, you learn on how to use activerecord to manipulate a database from a script Ruby. FXRuby as Marcelo said in another speech. Sinatra for web development, maybe will get the Merb course place, because Merb and Rails will be one. Shoes, as Marcelo said too, for Desktop development, very interesting. Ruby and Twitter, is a course that will be released now, i don't know when it will start, maybe april 14th or 16th, for who those already have a ruby knowledge, will be very interesting. They will show how to play with "Twitter API" and make some interesting things with it. And Rails 3, Satish promised that when Rails 3 is comming out he will create a course about it to everybody.

Slide21

This is some screenshots of shoes course. The application of the screenshot on the Right was made by Satoshi, that was the main teacher of Rubylearning shoes course, and is is a clock that show all the assistant teachers and mentors timezone on the world, all teacher have a photo placed on with their timezone. I asked Satoshi to send a message to all of you, and he sent to me a message with a "Google translation" Phrase in portuguese saying "Oi todo mundo" that probably is "hello everybody", and he says that you don't need to care about your english because we can communicate with Ruby, and he wants to see you on Rubylearning Forums. Here you can see other screenshot of a little game that they do with shoes, each student have your own game, you can see a "questions and answers" game on the next screenshot. Very interesting and a lot of fun!

Slide22

Here you have a message from Satish Talim, i asked to him to send one, and he is saying thanks to all Brazilian friends, Locaweb and Fabio Akita, that are sponsors of the course, the locaweb is a Sponsor of the core course, and saying thanks to you that are helping to spreading ruby around the world.

Slide23 - Questions

My presentation idea is to be very quick, just to show to you a bit of what is Rubylearning and how you can participate, what you will learn and so on... Somebody have some question?

Hugo: This courses that you show, all of them are free? Or have some paid courses too?

Willian: Yes, the core course is free. The other courses you need to pay to get in, but the cost is very low, something like 5 dollars, 3 or 5 dollars, just to maintain the website, Satish put a lot of his time on Rubylearning, so he need a way to maintain all of this, and he is making it with this paid courses and some sponsors, but is not high price, just 3 or 5 dollars with paypal.

Some other question? I trampled some content because I have little time.

Marcelo: Lets thank Willian, no more questions now...

slide23

Thanks! =)

Rails X Django

Unknown — Wed, 08 Apr 2009 00:00:00 +0000

Como todos sabem eu sou do mundo Ruby/Rails (Não sou xiita mas é o que mais gosto) e de vez em quando começo a brincar com coisas diferentes para poder formar a minha própria opinião sobre o assunto. No mes de fevereiro me surgiu um projeto bem interessante para trabalhar, pessoas legais, oportunidade legal, bem interessante! O projeto seria feito em Python/Django, e achei bem interessante a idéia de poder comparar várias coisas do Rails com o Django.

Bem...Vamos as minhas comparações:

Pontos fortes

Como primeiro argumento, e incontestável para mim, tenho que dizer que o admin do Django é muito legal! Você consegue fazer coisas bonitinhas e funcionais com uma facilidade espantosa! Sei que no Rails podemos fazer um scaffold ( ou até usar o ActiveScaffold, mas não é tão bom ) e criar facilmente um CRUD para mexer nos dados, mas isso não é um admin pronto, é apenas uma forma fácil de se manipular os dados. Penso eu que com o Rails seja mais facil de se criar um admin personalizado, com Design próprio, mas gostei bastante da solução a curto prazo do Django.
Achei bem interessante como podemos fazer a divisão de trabalhos com o nosso HTML(er) / JavaScript(er), por que o Django dá pouquíssima liberdade para o template com relação a código, ou seja, você define na sua view as query's que vão ser mandadas para o template e no template ele vai usar apenas o que você pode mandar, e não vai poder consultar ou fazer maiores alterações no conteúdo, portanto, quem deve cuidar de como o conteúdo vai chegar ao template são os programadores que vão enviar os dados para quem vai fazer a integração com o layout.

Pontos fracos

Não encontrei uma padronização / centralização para os plugins do Django...Você encontra vários modos de instalação para determinados plugins, alguns vem com setup.py, outros falam para você jogar na pasta do Python. Não tem algo centralizado como as gems do Rails ou os próprios plugins para jogar na pasta vendor/plugins, ou usar um script/plugin install ...
Não cria uma estrutura de pastas, deixando que você faça o que bem entender com a estrutura, ao invés de usar uma convenção sobre configuração.
Talvez seja a inexperiencia, mas eu não achei legal o que tivemos que fazer com o settings, pois cada um precisava colocar uma configuração diferente de diretórios de imagens, ou algumas configurações referentes aos plugins ( filebrowser no caso ), portanto cada um tinha que ter um settings.py diferente, informando o settings.py quando vamos executar alguma coisa.
Não me acostumei muito bem com o esquema de indentação do Python...Não que seja ruim, mas como estavamos trabalhando em sistemas operacionais diferentes de vez em quando aparecia um indentation error por causa de conversões de tabs em espaços e tal. Sei que esse argumento vai ser facilmente contestado com um: "É só configurar o seu editor de texto" ou "usa um editor de texto multiplataforma", mas mesmo assim...A idéia da indentação é legal, mas ainda me atrapalha um pouco.

Bem, é isso! Essas foram as minhas primeiras impressões do Django, como disse, não tinha experiência com o framework e muitas coisas poderiam ser evitadas mais facilmente, ou feitas de um modo bem melhor.

Continuo gostando bastante do Rails, mas achei muito legal várias idéias do Django, e acho que tem aplicações legais dependendo do projeto que você for usar. ;)

Ruby e Rails no mundo real

Unknown — Tue, 07 Apr 2009 00:00:00 +0000

Como muitos leitores do Blog sabem, eu palestrei no Evento "Ruby e Rails no mundo real", e vou fazer um pequeno overview desse evento que eu havia divulgado aqui no blog:

O evento foi bem interessante, bem alem do que nós havíamos planejado nas primeiras conversas do primeiro encontro do GURU-SP, e atendeu bastante as nossas expectativas por ser o primeiro. Obviamente cometemos alguns erros que vamos melhorar no próximo, como garantir que tenha Wi-Fi por exemplo! :)

Quanto as palestras, tivemos palestras interessantes, sendo a maioria delas de um grau não tão técnico como alguns estavam esperando, mas quem sabe no próximo planejamos algo mais hard para mostrar. ;)

Eu palestrei sobre o Rubylearning e acho que me saí bem, não foi a melhor palestra do evento (nem de longe...heheh) mas acho que consegui passar o que eu gostaria para a galera, espero ver mais pessoas lá no Rubylearning!

Para quem estiver afim de ver como foram os Slides pode dar uma olhada na versão em inglês que eu postei para mostrar para o pessoal do Rubylearning no Slideshare, e se alguem que não recebeu a apostila com os Slides quer ver a verão em português é só pedir que eu posto tambem. :)

O agaelebe gravou todas as palestras e assim que possível vai disponibilizar para os que não foram (e para os que foram e querem revisar algo).

Criamos uma página no GURU-SP.org para divulgar todas as informações sobre o evento, portanto se quiser saber qual foi a grade de palestras, ver as fotos e ver os vídeos ( assim que estiverem disponíveis ) é só acessar!

Projeto de fevereiro

Unknown — Fri, 03 Apr 2009 00:00:00 +0000

No mês de fevereiro eu estive envolvido com um projeto bem interessante na empresa que estou trabalhando (ainda vamos trabalhar mais em nosso site 😛), que foi feito em Python / Django e deveria gerar páginas estáticas ( exigência do projeto ).

Tivemos um prazo muito curto para tudo que deveria ser feito, o que gerou uma grande quantidade de trabalho fora do horário e dos dias comuns. Entre o começo e o fim do projeto, tínhamos o carnaval, portanto tivemos que deixar nossos espíritos carnavalescos guardados e partir para o trabalho árduo no feriado até horas indeterminadas.

O ambiente de trabalho era bem legal, trabalhamos onde chamávamos de The Rubens, que tinha tudo o que precisávamos para nos sentir a vontade:

Obviamente nada melhor do que instrumentos (para uma leve descontraída antes de voltar ao trabalho árduo), pessoas motivadas, barrinhas de cereal, livros (vários nomes interessantíssimos nessa biblioteca!) e programação! A única coisa que não tínhamos era tempo o suficiente para fazer tudo tranquilamente, mas aproveitamos bastante o tempo.

Trabalhamos todos os dias durante o carnaval, sábado, domingo, de madrugada, e em qualquer outro horário que fosse possivel ( hehe ). Nosso repositório Git já estava bem legal no gráfico de Network do GitHub, entre emaranhados coloridos!

Durante o caminho tivemos que enfrentar alguns contratempos, como o calor infernal, a falta de energia elétrica, a quantidade de novidades para lidar, tanto com o Python / Django, como com o Git e outras coisas mais!

Nenhum dos contratempos pode nos barrar muito! Com o calor vieram os ventiladores, com a falta de energia veio o nosso local de trabalho provisório (só durante aquele dia), e o prazo curto nós conseguimos vencer com muitas barrinhas de cereal e horas de trabalho.

Ahhh! É claro que no meio de toda a correria tinhamos que ter tambem o nossos momentos de descontração, alem do nosso amigo Darth Vader que aparecia na hora dos conflitos do merge… hehehe

Entre nossas descontrações (geralmente pouco antes de ir embora, 22:00h) tinhamos sessão violão e Sitar, ou momento Guitar Hero, ou jogo de alvo + dardos, um pouco de tiro com o Open Arena entre outras coisinhas.

Estavamos trabalhando com 2 Macs, 1 Windows e 1 Linux, portanto sempre tinha as boas e velhas conversas sobre o melhor sistema operacional, que é claro que o Linux é o melhor (haha, pelo menos aqui eu sou o root para dizer isso… hehehe).

Enfim…Foi um projeto corrido, dormimos pouco, trabalhamos muito, consideramos feriados e finais de semana como dias normais de trabalho, mas…Como diria o Rubens (algo parecido com isso):

É dos projetos mais difíceis que ficam as suas ótimas recordações

Portanto, na minha humilde opinião, se você tiver a oportunidade de entrar naquele projeto difícil com bons amigos, faça que vai valer a pena! :)

Update: Bem lembrado pelo Nelson! Nós temos o nosso vídeo de comemoração, quando terminavamos nossas features:

Ruby Inside Brasil

Unknown — Tue, 31 Mar 2009 00:00:00 +0000

Há um tempo já que eu deveria ter postado sobre o Ruby Inside Brasil, mas estou esvaziando aos poucos o meu Todo List e estou aproveitando a promoção que eles fizeram para liberar esse post tambem. :)

O Ruby Inside Brasil é a edição autorizada do Ruby Inside mantido pelo Peter Cooper. Uma ótima iniciativa para postar bom conteúdo em português.

A idéia inicial do projeto foi do Carlos Brando, que junto com vários outros colaboradores está contruindo o nome do Ruby Inside Brasil, e tem como idéia não apenas postar traduções dos conteúdos do Ruby Inside em inglês, mas tambem postar conteúdo próprio escritos por desenvolvedores brasileiros, cobrindo tudo que acontece relacionado a Rails e Ruby aqui Brasil!

Ajude a divulgar o projeto no Twitter, postando em seu blog, falando para os amigos e tudo mais. Se você possui uma empresa e quer patrocinar o projeto entre em contato com os responsáveis pela página de contato.

Parabéns a todos envolvidos no projeto. 😉

Colocando sua aplicação Rails na Dreamhost

Unknown — Wed, 25 Mar 2009 00:00:00 +0000

Estou fazendo um pequeno site em Rails e como tinha que mostrar o andamento para um colega, aproveitei para testar como seria o Deploy desse projeto na DreamHost ( mesmo sabendo que o provedor final não será lá ), e achei muito fácil de se fazer, portanto resolvi escrever um pouco sobre o processo. :D

Primeiramente, você precisa ter acesso SSH na sua conta. Se você ainda não tiver esse acesso apenas faça o seguinte procedimento:

Acesse o menu Users > Manage Users
Clique em Edit no user que você vai usar para o acesso SSH
Marque a opção Shell account - allows SFTP/FTP plus ssh access.

A partir daí você pode acessar por SSH assim como acessava por FTP, com esse usuário e senha. :)

Agora que temos acesso SSH a conta, vamos colocar nossa aplicação lá! Se ela estiver no GitHub você pode fazer um clone da sua aplicação facilmente:

git@github.com:usuario/projeto-qualquer.git

Se não estiver no GitHub você pode fazer um pacote tar.gz e enviar facilmente por scp:

tar cvf app.tar.gz aplicacao-quaquer/
scp usuario@xxx.xxx.xxx.xxx:/home/local/da/applicacao app.tar.gz

*Sendo que o xxx é o endereço IP ou Nome da sua maquina na Dreamhost

Com nossa aplicaçào lá, vamos criar o nosso domínio ou sub-domínio no painel de controle da DreamHost, pelo menu domains > manage domains.

Geralmente seu domínio demora um pouco para começar a funcionar, mas você não precisa esperar que ele esteja totalmente funcional para que você continue o processo ;)

O que você precisa fazer é:

Ativar o Ruby on Rails Passenger (mod_rails)
Apontar o Specify your web directory para o diretório public da sua aplicação

Agora que temos o nosso domínio criado e validando ( lembre-se que não é instantâneo ), podemos configurar o nosso banco de dados!

Acesse o Manage Mysql pelo menu Goodies > Manage Mysql e preencha o formulário que está logo abaixo dos bancos de dados já existente ( se houver ) para criar um novo banco.

Com o novo banco de dados criado, vamos adaptar nossa aplicação para usá-lo! ;)

Vá no arquivo config/database.yml e altere as informações da seção production para o que foi configurado no painel..

Agora com tudo configurado, vamos rodas as nossas migrations para as configurações de produção:

RAILS_ENV=production rake db:migrate

Com isso você já terá seu projeto funcionando assim que o domínio se propagar!

Foi bem mais simples do que eu pensava, como eu deixei o repositório com Git lá, basta eu fazer as alterações localmente e dar um push que já terei minha aplicação alterada lá! :)

É isso aí, espero que seja útil para vocês.

Curso de verão da USP

Unknown — Fri, 20 Feb 2009 00:00:00 +0000

Com o fim do curso de verão de 2009 da USP, resolvi postar minhas impressões sobre o mesmo!

O curso realmente foi muito bom e me ensinou muita coisa! Eu já tinha feito o curso no ano retrasado, mas não cheguei a terminar, por que o professor da época era muito foda e assumia que todos os alunos já sabiam do que ele estava falando, e para mim não significava tanto assim, portanto chegou um momento que eu simplesmente já não estava entendendo mais nada, e o professor já estava jogando matéria loucamente, portanto abandonei.

Esse ano, assim como no ano retrasado, não fui sozinho. o Rodrigo foi comigo também, apenas de ele não cursar algo relacionado a programação (cursa redes), ele resolveu fazer o curso. Lá também encontrei a Suelen, que participou do curso no ano retrasado também! Tudo isso sem contar que ainda reencontrei outras pessoas que fizeram o curso junto comigo em 2006, e que resolveram aparecer agora. :D

Esse ano tivemos um professor muito gente fina chamado Wanderley Guimarães que explicou a matéria muito bem durante todo o curso, ensinando até coisas que não faziam parte do curso para quem não entendia o suficiente, e indo além do que o curso previa para quem sabia muito mais do que o normal. O professor é realmente muito legal, e a aula realmente se tornava bem divertida de ser assistida, pois sempre tínhamos certeza que viria um conteúdo interessante além dele estar sempre disposto a conversar no final da aula.

O que foi abordado no curso:

Iteração, indução e recursão
Prova de invariantes
Análise de tempo de execução de algoritmo
Vetores
Listas encadeadas
Pilha e Fila
Buscas simples e busca binária
Ordenação
Insertion Sort
Selection Sort
Merge Sort
Heap Sort
Quick Sort
Árvore Binária
Árvore Binária de Busca

No final do curso ainda tivemos uma introdução a Programação Dinâmica e a algoritmos de enumeração! :)

A cada tópico passado tínhamos um estudo utilizando os outros tópicos já aprendidos. Exemplo: Vamos estudar o MergeSort, então provamos as invariantes / indução, fazemos ele tanto recursivo quanto iterativo, vemos a quantidade de tempo e memória que o algoritmo utiliza e outras coisas mais.

As aulas se tornaram bastante interativas pois o Wanderley sempre dava bastante liberdade para a classe intagir com o conteúdo, as vezes até propondo algoritmos interessantes "On the fly" na aula. :D

O curso é baseado em 2 provas e um EP (exercício programa) para avaliação. Eu não fui muito bem na primeira prova, e espero ter me saído razoável na segunda, e empenhei uma boa parte do meu tempo noturno no EP para ver se no fim das contas eu ainda consigo sair com o certificado. ;)

Como é de praxe, no final do curso tínhamos menos da metade da sala com participantes ativos, pois muitos não se adéquam ao curso ou acham muito difícil e desistem. Nesse momento do curso o Rodrigo já não estava indo mais (o que eu já tinha previsto, não sei por que, e aí está a foto com minha moto sozinha em frente ao prédio do IME), e eu permaneci aprendendo tudo o que eu podia antes do fim do curso, mesmo que minhas notas não estivessem como eu gostaria. :P

O EP desse ano foi bem interessante, deveríamos receber uma quantidade indeterminada de palavras, sendo que elas seriam informadas uma por linha pela entrada padrão, e o programa deveria imprimir todas as palavras que eram anagramas umas das outras na mesma linha, e as que não eram anagramas na linha seguinte... Algo como:

teste
marrocos
futebol
pothix
bolfute
eetts
socorram

Ia retornar:

teste eetts
marrocos socorram
pothix
futebol bolfute

A princípio parece fácil, mas quando você começa a fazer percebe que não é tão simples assim. ;)

Só uma dica...Dá para fazer com lista encadeada. ^^

Espero sair com o certificado desse curso, pois me empenhei o máximo que pude, mesmo com todos os transtornos que aconteceram, e com a terrível falta de tempo. Mesmo querendo sair com o certificado, ele não é o mais importante do curso, o que mais importa é a quantidade de conhecimentos que eu consegui agregar, a quantidade de pessoas interessantes que eu conheci, e a quantidade de experiência que isso me trouxe. :D

Pretendo fazer vários posts sobre os conceitos que eu aprendi no curso por que eu acho que será bem interessante passar esse conhecimento para outras pessoas.

Eu tenho uma recomendação...Aproveite suas férias de janeiro do ano que vem e vá fazer um curso de verão! ;)

DC++ no Linux

Unknown — Mon, 09 Feb 2009 00:00:00 +0000

Hoje finalmente estou conseguindo escrever um post sobre o DC++! Desde a Campus Party eu quero escrever esse post mas nunca consigo tempo!

Para quem não conhece, o DC++ é um software para compartilhamento de arquivos, muito interessante, onde você pode facilmente compartilhar arquivos pela rede local, e por isso mesmo que foi muito utilizado na Campus Party, onde os campuseiros compartilharam terabytes e mais terabytes de arquivos!

Atualmente estou utilizando Ubuntu no meu notebook (não tenho mais PC nem em casa e nem no trampo, portanto o meu Slackware se foi...:() e vou mostrar aqui como instalar o seu DC++ nele!

Primeiramente vamos instalar as dependencias:

sudo apt-get install bzr scons build-essential libgtk2.0-dev libglade2-dev zlib1g-dev libbz2-dev libssl-dev

Como é possível notar acima, estamos instalando tambem o Bazaar, que é o software de controle de versão que o DC++ utiliza, infelizmente ainda não tem os binarios para nenhuma distribuição por que ele ainda está em alpha, por isso temos que fazer o download direto pelo Bazaar!

bzr branch lp:linuxdcpp

Agora temos um branch local do DC++ no nosso computador, portanto é só entrar na pasta e instalar:

cd linuxdcpp
scons release=1 PREFIX=/usr/local
sudo scons install

Veja que criei um "PREFIX" para instalar em /usr/local. =)

Agora seu DC++ já está instalado e você pode executar ele usando o comando:

linuxdcpp

E pronto!

Agora é só clicar no botão connect e conectar ao endereço de compartilhamento e já era! :)

No site que tirei essas dicas eles falam que é bom desabilitar o "Assistive Technology Support" por que deixa o DC++ muito lento. É só ir em: Sistema > Preferencias > ATS

Espero que seja útil para vocês assim como foi para mim no Campus Party!

Ruby e Rails no mundo real

Unknown — Fri, 06 Feb 2009 00:00:00 +0000

Pessoal, hoje o meu post é para comentar sobre o evento do Guru-sp (Grupo de usuário Ruby de São Paulo), cujo fui um dos fundadores e participo até hoje (quem vê pensa que faz bastante tempo... Apenas uns 4 meses haha).

O evento já tem site oficial e está com as inscrições abertas!

Pelo que estamos fazendo o evento tende a ser grande, com auditório para cerca de 200 pessoas, com direito a crachá, apostila, Coffee break e etc.

Vou passar mais informações sobre o evento:

Data: 04/04/2008 ( Sábado ) Horário: das 09h às 18h Local: Century Flat Paulista

Palestras / palestrantes que você verá por lá:

Carlos Brando - Vai falar sobre testes, que é algo muito importante em projetos! Carlos é o criador da gem Remarkable para integração de Shoulda e RSpec.
Vinicius Baggio - Vai falar do seu projeto de Instant Messenger em Rails, e como foi a criação do mesmo, que parece ser bem interessante!
Hugo Borges (agaelebe) - Vai apresentar uma palestra sobre Ruby, Rails e empreendedorismo
Marcelo Castellani - Vai palestrar sobre Ruby Desktop, falando sobre Shoes, FXRuby e outros
Rodrigo Franco (caffo) - Vai falar sobre Outsourcing, e como é o trabalho para empresas do exterior.
Maurício Leal - Fará uma apresentação sobre escalabilidade utilizando GlassFish com Rails
Fabio Kung - Vai falar sobre análise de código com ParseTree
Willian Molinari (PotHix) - Sim... Esse rapaz é nada mais nada menos que....EU! :)

Pretendo falar um pouco sobre o Rubylearning, qual é a vantagem de estudar junto a uma comunidade, comentar sobre as particularidades do curso core do Rubylearning, comentar sobre os novos cursos que estão aparecendo por lá, tirar algumas dúvidas do pessoal que ainda não conhece.

Espero ver o pessoal por lá prestigiando o evento. ;)

Qualquer dúvida pode postar nos comentários, e vou atualizando o post com as novidades do evento.

Update 13/02: Alterado o local do evento! ; )

VIVO online agora funciona no Firefox / Safari

Unknown — Fri, 30 Jan 2009 00:00:00 +0000

Boas novas!

Eu tinha feito um post sobre os usuários dos serviços da VIVO que tiveram que desenvolver uma extensão para conseguir acessar os serviços do Vivo on line, e agora a vivo anunciou oficialmente em seu blog que o Vivo on line funcionará bem em outros navegadores diferentes de Internet Explorer! :)

Tudo bem que isso é um direito nosso e já deveria funcionar em todos desde o começo do serviço, pois prejudicava os usuários de outros sistemas operacionais diferentes do Windows, mas temos que parabenizar a VIVO por trabalhar em cima do problema que tinham e resolver assim como prometeram em novembro do ano passado!

Que a VIVO seja a primeira de muitas empresas a refatorar o seu site e sirva de exemplo para muitas empresas que estão aí na internet prestando maus serviços.

Campus Party 2009

Unknown — Mon, 26 Jan 2009 00:00:00 +0000

Como sabem eu estive na Campus Party nessa ultima semana, e consegui aproveitar bastante do evento, apesar do monte de coisas que estão acontecendo na minha vida e a correria toda de trabalho, curso e outras coisas.

Segue um pequeno resumo do que pude ver por lá:

Segunda-feira dia 19/01/2009

Cheguei no evento mais ou menos as 15:00 e consegui entrar rapidinho... Já armei a minha barraca (vide fotos) e deixei algumas coisas por lá para não ficar carregando, e fui conectar na internet que ainda estava bem precária que só funcionava em algumas mesas. Fiquei pouco tempo acessando a internet, pois tive que fazer a minha peregrinação diária de ir para a USP para fazer o curso de verão de tópicos de programação.

Voltando do curso (mais ou menos 23:00), após passar em casa volto para cá para ver como estão as coisas, e ainda consegui ver a abertura do evento, com direito a Serra, Kassab e o Tim Berners Lee!

Após todas as festividades fiquei esperando as primeiras atividades que supostamente começariam 1:00, mas não vi nada de diferente e continuei na minha mesa até umas 2:30 mais ou menos quando resolvi me recolher para a minha barraca e dormir.

Veja aqui as fotos do dia

Terça-feira dia 20/01/2009

Acordei as 8 da manhã para ver a palestra do Fabio Akita sobre ecossistema RubyOnRails e até fui mencionado por ele quando ele falou sobre o Rubylearning (obrigado Akita!). Foi uma palestra bem legal falando dos mitos do Rails, mostrando um pouco de código e tudo mais...para quem não conhece o Rails foi uma geral bem legal.

Depois da palestra fui conversar com o Fabio e ficamos um bom tempo batendo papo enquanto conhecia a equipe da Locaweb ( inclusive o @locaweb_reply ! haha ). O pessoal da Locaweb estava com uma camiseta bem legal com os dizeres:

1F U C4N R34D 7H15 U N33D 70 G37 4 L41D

Tentei de toda forma ganhar uma, até por que era a camiseta de Linux da Locaweb, mas no fim das contas não consegui e fiquei somente com uma revista mesmo.

Consegui começar a aproveitar a internet, fazer uns downloads e ver uns vídeos! :)

Depois comecei a procurar (ou não) e encontrar uma galera legal, como o agaelebe e o Mario Rinaldi da fundação Mozilla no Brasil.

Sai na hora do almoço e fui para casa (sim, estou almoçando e tomando banho em casa, já que moro perto daqui, então estou apenas dormindo aqui por diversão), quando voltei ja era 16:00, e ainda consegui assistir a apresentação sobre Podcasts com Maestro Billy, Mellancia, Jovem Nerd, Azaghal, Dani Brau e Guilherme Felliti, que por sinal foi bem interessante! No final ainda consegui tirar uma foto com o Alottoni e uma com o Azaghal ( e nessas fotos estou comprovando que não sei sorrir. :))

Ahhh! Outra coisa legal que consegui foi além de conhecer o Karlisson, ainda consegui tirar uma foto com a celebridade criadora do nerdson.

Encontrei tambem meio que de passagem a Bruna Griebeler quando eu estava chegando e ela saindo...Deu para conversar bastante ainda com o pouco tempo que tinha. :)

Chegando aqui tarde novamente, percebi que perdi a palestra sobre desenvolvimento de games com C++, que é uma das coisas que estou estudando... Tive 2 notícias, uma boa e outra ruim... A boa era que iam ter palestras de desenvolvimento de games a semana toda! (uhuuu) e a notícia ruim é que cai no horário do curso de verão (duuuhhh), portanto não vou conseguir assistir nenhuma.

Veja aqui as fotos do dia

Quarta-feira dia 21/01/2009

Peguei um HD externo de 40Gb para fazer download de umas coisas para um colega meu, e descobri o DC++ que o pessoal estava usando aqui internamente, o que deixa o compartilhamento de arquivos com uma velocidade monstruosa, e comecei a encher o meu HD que estava com 160GBs livres ( fora o HD externo de 40 ).

Assisti uma palestra sobre SEO, que foi bem interessante apensar do som que estava horrível de ouvir por causa dos outros sons que estavam em volta e o volume do som dessa area que estava muito baixo.

Assisti a palestra do Luciano Ramalho ( presidente da associação Python Brasil) sobre Python (obviamente), que apesar de alguns problemas com o projetor, foi interessante e mostrou várias coisas diferentes. Após a palestra ainda consegui conversar com o Luciano um pouco (já fiz um curso de Python ministrado por ele na Impacta).

Assisti a ótima palestra do Manoel Lemos do Blogblogs, que falou sobre a infra-estrutura do blogblogs e do Brasigo ( vide fotos), que foi crescendo aos poucos, assim mostrando um case de sucesso que começou simples e aos poucos foi crescendo com inteligencia. Na minha opinião essa palestra é ótima para desenvolvedores Rails (e não Rails também) que tem aplicações que podem crescer rápidamente e precisar de uma mudança de estrutura para continuar prestando um bom serviço.

No final da palestra apareceu um slide dizendo "estamos contratando novos Jedis"! Isso muito me interessa! ;)

Assisti no CPLabs uma apresentação sobre o OpenVC, que é uma biblioteca C++ para trabalhar com webcam, que é muito interessante! Dá para captar movimentos e fazer várias coisas divertidas! Na palestra foram apresentados vários vídeos legais.

O mais legal do dia foi ter cumprimentado e tirado

uma foto com nada mais nada menos que John "Maddog" Hall!! Sim, ele mesmo, o do software livre e diretor executivo da Linux International!

Finalmente hoje encontrei a Bruna Griebeler novamente, mas como sempre na saída de um dos dois, mas dessa vez er a minha (estava saindo para almoçar em casa), mas após ficar batendo papo, aproveitamos para fazer inscrição para ganhar um domínio grátis por um ano no stand do IG! E acabei indo almoçar as 16....hahaha

Após voltar do curso da USP, tive que começar a me focar nos exercícios para entregar na quinta feira (sim...é amanhã), portanto fiquei até as 3 da manhã trabalhando nisso, e só não fiquei mais por que estava muuuuiiitooo frio, portanto preferi ir para a minha barraca quentinha. :P

Veja aqui as fotos do dia

Quinta-feira dia 22/01/2009

Acordei um pouco mais tarde e tirei o dia para mexer nos exercícios, portanto fiquei pouco na Campus Party.

Hoje, além do Mario Rinaldi que resolveu aparecer novamente (ele tem o poder de desaparecer... hahha ), o Marcelo Castellani do guru-sp apareceu por aqui também, o que rendeu a única foto do dia com uma qualidade horrível.

Conversando com o Rinaldi eu consegui pegar a minha camiseta do Mozilla Firefox ( melhor navegador do mundo! haaha ), e de quebra conheci outro cara da fundação Mozilla, que é o Bruno Magrini! :)

Depois disso tive que resolver uns problemas e terminar uns exercícios em casa para ir para USP.

Depois de resolver mais problemas volto ao campus party para escrever no blog até as 5 da manhã, estudar C para a USP (por que tenho prova na segunda feira) e baixar trecos legais! :)

Veja aqui as fotos do dia

Sexta-feira dia 23/01/2009

Sexta feira foi um dia legal por aqui! já menos preocupado com a lista de exercícios (mas preocupado com a prova de segunda), eu consegui fazer bastante coisa, conversar com várias pessoas, e tudo mais.

Encontrei o pessoal do Guanabara.info!

Conversamos com o Gustavo Guanabara, demos uma volta pela feira, vimos como são feitas as pautas do Podcast, conhecemos o Kaue Linden da HostNet (que por sinal é muito gente boa!), ganhei uma camiseita do Guanabara.info e uns adesivos! Foi bem divertido encontrar essa galera e conhecer o Guanabara pessoalmente. :)

No fim das contas ainda fiquei pouco tempo por aqui (das 19:00 as 22:00), mas valeu a pena!

Veja aqui as fotos do dia

Sábado dia 24/01/2009

Após ficar até as 4 da manhã estudando na casa de um amigo, durmi um pouco e vim direto para cá! :)

Encontrei o Marcelo Castellani do guru-sp, e ficamos um bom tempo batendo papo com o Fabio Akita, e isso se tornou o segundo encontro do guru-sp ( que estava marcado aqui na Campus Party)! :)

Após as conversas eu peguei minha camiseta do Guru-sp com o Marcelo e fiquei com as camisetas do pessoal que talvez iria aparecer por aqui, e consegui entregar uma para o Ricardo Yasuda ( Shadow11).

Assisti um pedaço da palestra do Karlisson sobre quadrinhos, onde ele mostrou algumas particularidades das imagens, e fez uma tirinha durante a palestra ( infelizmente cheguei tarde para ver essa parte ).

Assisti um pedaço da palestra sobre app engine do pessoal do GruPy, que foi bem interessante! Eles trouxeram palestrantes internacionais para falar sobre app engine, e o assunto foi bem legal para quem não conhece o app, está afim de brincar com Python e quer uma boa estrutura para deixar sua aplicação gratuitamente! :)

E teve várias outras palestras legais que eu gostaria de assistir, mas infelizmente eu só posso estar em um lugar ao mesmo tempo ( acho que eu preciso da filosofia "Fork you" do GitHub...haha ), portanto não pude assistir outras como a de Desenvolvimento de games com C++...

Tinha planejado ir para casa e depois ir para a casa de um amigo estudar a madrugada toda novamente, mas no fim das contas acabei ficando na Campus Party mesmo por vários motivos, e foi bem divertido ficar lá papeando e se divertindo com o Pessoal da Moz-br (Clauber-halic, Bruna Griebeler, Hermano Silva e Mario Rinaldi, o Karlisson e o InFog (vejam nas fotos).

Teve uma coisa que precisa ser comentada! Teve dois caras correndo pela Campus Party nesse dia, um vestido de PacMan e o outro vestido de fantasma com uma sirene! hahahaha! Parabens ao cara que pensou nisso, por que foi muito criativo, pena que não tenho as fotos.

Desmontei minha barraca e saí de lá as 6 da manhã mais ou menos. ;)

Veja aqui as fotos do dia

Considerações finais

A Campus Party para mim terminou no Sábado, mas domingo a area Expo ainda estava aberta para visitas, mas resolvi não aparecer por lá já que na area Expo não tinha muita coisa.

Gostei bastante do evento! Considerei como uma aventura, passar uma semana dormindo fora ( durmindo pouquíssimo e sem horário certo hehe ), acessando a internet rapidíssima, comendo pouco, estudando, fazendo networking e se divertindo!

Conheci muitas pessoas legais (e outras que pensei que fossem legais e nem são), me diverti bastante, tirei fotos legais, preparei caminho para o futuro ( se acontecer algo eu postarei ), baixei muita coisa ( 200GB), gastei uma graninha com estacionamento e refeição e estou bem mais tranquilo para voltar ao trabalho depois de uma semana fazendo coisas que eu adoro (programar, conversar sobre tecnologia, acessar a internet).

Tiveram coisas bem legais acontecendo por lá e outras que não foram tão legais, mas é claro que todos os eventos tem seus defeitos, e esse evento para mim foi muito bom!

No fim das contas...pretendo voltar lá ano que vem! :D

Usuários resolvem os problemas da VIVO

Unknown — Tue, 13 Jan 2009 00:00:00 +0000

Primeiramente quero parabenizar o Diogo Santos pelo seu add-on para Firefox, que faz com que o botão "entrar" do site da Vivo funcione sem que você tenha que usar javascript para manipular pela barra de endereços. Parabéns Diogo, é uma ótima contribuição para a comunidade.

Agora vem a hora da crítica... Como que os usuários tem que ficar desenvolvendo formas alternativas para acessar os serviços que deveriam funcionar para eles, mas por descaso e serviço mal feito não lhe são concedidos? Eu acho impressionante o descaso de tais operadoras por determinadas coisas.

O pior de tudo é que quando você entra em contato pelo suporte a resposta que te dão é a seguinte:

Não damos suporte a outro navegador que não seja o Internet Explorer

Ou seja... Caso você esteja no Linux ou no MacOs o problema é seu... Eles não estão nem aí se estão simplesmente excluindo essas pessoas.

A nossa sorte é que a comunidade é auto-suficiente, e temos pessoas que trabalham a favor da comunidade (e não a favor da VIVO), sempre ajudando para que os serviços mal feitos funcionem, e o Diogo é um ótimo exemplo disso.

Após acessar o site da Vivo com o plugin do Diogo, eu percebi que ainda tem vários serviços que ficam indisponíveis, mas quem sabe a comunidade dá um jeito nisso com o tempo, ou até mesmo a VIVO toma vergonha na cara e resolve prestar um serviço de internet de qualidade.

Fica aí a minha crítica a VIVO e a parabenização ao Diogo!

Fora IE6

Unknown — Mon, 12 Jan 2009 00:00:00 +0000

Já está mais do que na hora de eu fazer um post sobre isso, e acho que não há momento mais propício do que esse afinal, até o Google já está dando alertassobre isso no Gmail. Sabemos que o Gmail é não é o serviço mais acessado do Google, mas isso já é uma grande ajuda para alertar os desavisados que esse navegador já passou da hora de deixar de existir, e quem sabe num futuro talvez distante ( espero que não tão distante assim ) o google resolva fazer algo parecido com o Orkut! :)

Há muito na internet sobre o quanto o IE6 é ruim, e minha opinião não difere muito da opinião dita em posts como o do Fabio Akita, ou do Canha por exemplo ( O logo ao lado foi tirado do blog do Fabio Akita todos os créditos para ele! ).

Muita gente que me conhece pode dizer:

Ahhh....vc não gosta da Microsoft e fica fazendo propaganda de browsers Open Source

Mas na verdade não é somente por isso...Mesmo que vc vá continuar com o IE (não recomendado, mas menos mal), pelo menos atualize para uma versão mais recente, pois usar o IE6 hoje em dia é completamente inaceitável!

Alguns ainda tem a audácia de me perguntar o por que de eu ser contra o IE6 e aqui vão alguns argumentos completamente lógicos para o fato:

É um produto desatualizado que já tem uma versão mais nova lançada e outra no forno para sair sei lá quando
É um produto que foi lançado numa época em que ele precisava estar na frente para bater outros navegadores, portanto não estava nem aí para padrões, bom desenvolvimento ou qualquer outra boa prática que pudesse existir.
Você que usa IE6 não sabe o mal que está fazendo para tantas pessoas que trabalham com internet e precisam perder preciosas horas do seu dia para ficar fazendo hacks para que seu site ( que segue os padrões de desenvolvimento para internet, bem documentados aqui ) funcione num produto desatualizado que deveria ter sumido já.
Ele dá um grande break na evolução das tecnologias, pois muitas das coisas legais que os desenvolvedores querem fazer ( transparencia por exemplo precisa colocar Hack bizarro para funcionar no IE6 ) devem ser pensadas e repensadas, pois pode não funcionar legal no IE6, e seu chefe com certeza não vai deixar você colocar no ar algo que não funcione legal no IE6, por que ainda tem uma grande massa que usa isso.

Já ouvi argumentos de pessoas que gostam do visual do IE6, que é totalmente aceitável, afinal, qualquer pessoa pode usar o que acha mais legal, bonito, fácil.,ou sei lá o que consideram, mas se for somente por isso você pode seguir a dica que o canha deu no post dele:

No Firefox, inclusive há um tema que se parece com o IE6 para você não se sentir perdido. E o melhor: todos estes navegadores possuem versão em português.

Eu estou fazendo a minha parte para começar o ano bem e estou instalando aqui no meu blog um plugin para alertar os usuários desse software antigo para atualizar para algo melhor.

Não sabe como fazer? Veja aqui os links para instalar um browser diferente:

Firefox
Chrome
Opera
Safari
Internet Explorer 7 (prefira os acima, mas se gostar mesmo do IE instala esse que é melhor)

Acho que consegui dar motivos o suficiente para você trocar de browser, se ainda tem alguma coisa que você usa não terá em outros browsers, me avise que farei o possível para encontrarmos uma boa solução para isso.

Deploying a simple Merb application on Locaweb

Unknown — Wed, 07 Jan 2009 00:00:00 +0000

I writing this post to help my friends of Rubylearning with a little Merb application deployment on Locaweb. I'm just translating some informations that you can find here in portuguese.

Lets get started! :D

First open the

Domain Manager (gerenciador de domínios) on Locaweb Panel (painel da Locaweb) and configure the pointer of your main site to other directory on public_html of your account (this directory don't need to exist).

Follow this steps:

Click on "alterar" (change)
Change the "Diretório Web" (web directory) to the new diretory
And click on button "Salvar" (save)

Transfer your application to this directory on your host. For this example, lets say that your application is called "sample_merb", so, connect via SSH on your account and create the directory "rack_app":

mkdir -p rack_app/sample_merb

And move your application to there.

Your application must to have a file called "config.ru" to be executed by Phusion Passenger, so, you need to create this file on your application folder (rack_app/sample_merb on this case) with this content:

require 'rubygems'
require 'merb-core'

Merb::Config.setup(:merb_root   => “.”, :environment =>; ENV['RACK_ENV'])

Merb.environment = Merb::Config[:environment]
Merb.root = Merb::Config[:merb_root]
Merb::BootLoader.run
run Merb::Rack::Application.new

Now you need to create a symbolic link on your public_html diretory, as you have configured on your Domain Manager (gerenciador de domínios) of Locaweb Panel.

ln -s ~/rack_app/sample_merb/public ~/public_html/sample_merb

By using this simple configuration you will have your application pointed by apache with Phusion Passenger.

Just to you know, you can see the merb gems that are installed with:

gem list | grep merb

Hope this help you on how to make your simple application works on Locaweb. ;)

Configurando seu git para começar a usar

Unknown — Sun, 21 Dec 2008 00:00:00 +0000

Meu ultimo post foi sobre como subir um projeto para o GitHub, mas me veio agora uma vontade repentina de falar como deixar seu git legalzinho para começar a criar repositórios e contribuir com códigos! Serão apenas configurações básicas, mas que são bem úteis quando você estiver usando o Git ativamente!

Antes de mais nada precisamos instalar o Git, portanto é só baixar ele no repositório oficial e fazer a instalação referente ao seu sistema operacional.

No meu Slackware já veio o Git instalado belezinha, portanto foi moleza! No máximo eu atualizei com o SlackPkg.
No Ubuntu se eu não me engano eu precisei instalar, mas foi moleza, só baixar o .deb oficial e usar o dpkg -i :)

Vamos as configurações:

Primeiramente precisamos de configurar o nosso nome e e-mail:

git config --global user.name "PotHix"
git config --global user.email "PotHix@pothix.com"

Algora alguns Alias para facilitar:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.br branch

Agora algumas cores para facilitar a leitura quando digitarmos os comandos:

git config --global color.status auto
git config --global color.branch auto
git config --global color.diff auto

Podemos já criar um projeto simples e enviar para o GitHub assim como eu fiz no post anterior mas agora já usando os nossos alias para ficar mais fácil! :)

Com Git podemos fazer várias outras coisas que vou falando aos poucos em outros posts, esse aqui é só para mostrar como deixar seu git mais legal para começar.

Iniciando seu primeiro projeto no GitHub

Unknown — Sun, 21 Dec 2008 00:00:00 +0000

Hoje estou aqui para postar um pouco sobre o GitHub! =)

Minha idéia hoje é apenas mostrar como você inicia um projeto por lá, ou seja, enviar um pequeno repositório git e deixar no GitHub, e conforme os meus progressos eu postarei mais coisas por aqui! ; )

Antes de começar tudo isso você precisar ter cadastro no GitHub (obviamente) e já ter uma public-key cadastrada.

Para cadastrar uma public-key é só logar no GitHub, clicar em account (no canto superior direito) e clicar em "add public key" que vão aparecer os campos para inserir a mesma.

Você pode encontrar a sua public key no diretório ~/.ssh com o comando:

cat id_rsa.pub

Caso ele não exista basta acessar sua home (~) e cria-lo com:

ssh-keygen -t rsa

OBS: Eu tenho um post com mais informações sobre chave e SSH.

Depois pegar o conteúdo do arquio id_rsa.pub e colocar lá no GitHub. Voltando a criação do repositório... Primeiramente crie um diretório por aqui:

Depois de criar você já terá um local acessível para enviar seu código, que por sinal ainda não existe, portanto....Vamos criá-lo! :)

Primeiramente crie um diretório qualquer:

mkdir codes

Acesse o diretório:

cd codes

E vamos iniciar o git nesse repositório:

git init

Coloque aqui seu arquivo de código (não necessáriamente código, mas nesse caso vamos usar código ;)) e vamos adicioná-lo ao git:

git add mycode.rb (obs: Ruby o/)

Agora vamos dar um commit do que fizemos usando "-m" para deixar uma mensagem do motivo do commit:

git commit -m "Meu primeiro commit"

Agora vamos adicionar como origem o nosso projeto criado no GitHub:

git remote add origin git@github.com:seu-usuario-no-GitHub/nome-do-repositorio-criado.git

E depois é só dar um:

git push origin master

E lá está o seu código no GitHub! :)

Tudo que eu falei aqui está no tutorial do GitHub quando você cria um diretório:

http://github.com/guides/setting-up-a-remote-repository-using-github-and-osx

Por enquanto é isso! Algo bem simples só para você não se assustar quando lhe falarem de GitHub.

Ir além do básico tambem é gratis

Unknown — Thu, 11 Dec 2008 00:00:00 +0000

Faz um tempinho que eu estou querendo fazer um post seguindo os moldes da campanha do Marco Gomes, que também gerou o post do Diego Eis, e finalmente consegui um tempinho para expressar também a minha opinião nesse assunto! :)

Conheço muitas pessoas que fazem faculdade relacionada a programação, mas não aplicam o que estão vendo por lá, acham que já estão fazendo demais em ir para a faculdade e ficar lá no tempo em que o professor está falando...Ou seja, essas pessoas não estão indo a faculdade para aprender algo para colocar em prática, eles estão lá simplesmente para "passar de ano".

As vezes não é nem tanto com faculdade também, tem pessoas que não fazem faculdade, querem ser programadores, mas tem aquele pensamento:

Ahh... Eu preciso de uma oportunidade para aplicar os meus conhecimentos

A internet está aí para isso! Você pode ter uma gama monstruosa de ferramentas para brincar se quiser, tantos livros gratuitos para aprender/melhorar sua programação, tantos projetos Open Source para contribuir, cursos on-line gratuitos para fazer, mas o sujeito quer "ganhar uma oportunidade" sem nem mesmo merecer ela.

Esse tipo de pessoa para mim não é programador!

Gostaria de aprender a fazer isso por que é muito foda, mas parece muito difícil, então vou fazer o XY que é mais zuadinho mas é fácil

Apertar parafusos também é fácil...Se as coisas fossem fáceis colocaríamos robôs para fazer...

Estou trabalhando na empresa XY mas já estou cansado de lá...Cansei de suporte técnico, eu quero é ir programar, mas sem experiência fica difícil

Vá e consiga sua experiência sozinho, faça um site e mostre quando for na entrevista, como que o cara quer ter experiência sem fazer nada....

Putz...Não conheço nada de Linux esse sistema é uma merda...

Esse é um candidato perfeito a ser um ótimo programador não é?!

Primeiro já caiu numa contradição, por que se ele não conhece nada, como sabe que é uma merda? E outras, não quer nem conhecer um sistema diferente onde ele terá suporte nativo a várias linguagens, e não só isso, só o fato de não querer aprender algo gratuito e importante para a carreira já faz dele uma pessoa pouco interessante!

Portanto, vamos a alguns pontos importantes:

Invista tempo em aplicar o que você aprende na faculdade, ou caso não faça faculdade, corra atrás de coisas para estudar e aplique elas também.

Procure coisas diferente para saber, afinal, quanto maior a sua gama de conhecimentos mais difícil será você dizer para alguem: "Não sei nem o que é isso".

Desenvolva coisas úteis e mostre seus código na internet, isso ainda vai ser muito útil para você (tanto para aprendizado quanto para apresentação pessoal). ).

Para finalizar só quero frisar uma frase do post do Marco Gomes que émuito interesssante e resume muito a minha opinião:

"Você pode mudar sua vida, e até mudar o mundo, com o mesmo equipamento que usa pra ficar o dia inteiro no orkut trocando recadinhos com as peguetes"

Como são os primeiros passos de um Linuxer

Unknown — Sat, 29 Nov 2008 00:00:00 +0000

Nesse post eu vou contar um pouco de como são os primeiros passos de alguem que quer mesmo brincar com Linux. No caso vou falar como eu comecei com o Linux! Vamos lá! :)

Eu sempre ouvia falar de Linux quando eu lia Livros sobre segurança e tudo mais, portanto sempre tinha vontade de utilizar... Meu primeiro contato direto com Linux foi em 2004, mas nessa época eu ainda era bem fanático por jogos de computador, o que me fez continuar no Windows por um tempo.

No meio de 2005 eu comecei a utilizar a minha primeira distro de Linux, que foi o Kurumin!

Ele seguia o mesmo caminho que o Ubuntu segue hoje, que é facilitar o Linux para o usuário doméstico, ele era até bem legal, mas na época eu sofria muito por ter internet discada, e nos tempos com Linux é muito difícil, principalmente para um usuário inexperiente.

Na época eu não podia ter banda larga por vários motivos, portanto a única solução era a discada mesmo, então eu tentei várias formas para sobreviver com Linux assim, testei várias versões do Kurumin, peguei vários softmodens emprestados para saber qual funcionaria bem, comprei um hardmodem USRobotics para ver se conseguia fazer funcionar 100%, mas não adiantou muita coisa...

Mesmo com os meus problemas com internet discada, essa foi a época que eu aboli de vez o Windows e fiquei somente com o Kurumin na minha maquina, pois eu descobri que o Kurumin 4.2 funcionava com meu moden Intel537Ep.

Posteriormente quando comecei a fazer ETE, e lá eu tinha matérias como C# e VB.net onde eu tinha que usar o Visual Studio, portanto precisava do Windows instalado novamente, e ainda por cima consegui meu primeiro trabalho com programação (uhuu!) trabalhando com ASP e VB.NET (duuhhp) , portanto fui obrigado a voltar para o Windows, e mesmo com dual boot o Kurumin um pouco de lado.

Durante a ETE tive um trabalho sobre o Linux para fazer, onde tive que conhecer melhor o Kalango... Instalei ele, dei uma brincada, mas realmente não gostei da distro... Se fosse para utilizar o Kalango eu ficava no Kurumin mesmo.

Durante esse tempo eu tambem tentei brincar com o Slackware, mas devido a internet (novamente) eu não tive a menor chance contra ele... Minha experiência era muito pouca para poder fazer funcionar um modem para acesso discado no Slack. :P

Quando finalmente consegui ter internet banda larga eu já resolvi extrapolar para aprender e usar o Slackware de vez! :)

Foi a época que eu penei bastante para aprender coisas simples que eu não tinha noção e que o Slackware deixa para vc se virar ao invés de tentar fazer com alguma fórmula mágica, e esse foi o principal motivo de eu usar Slackware, para saber onde e porque as coisas acontecem.

Agora com a internet banda larga (não tãão larga assim) funcionando ficou bem mais fácil de usar Slackware, afinal, se tinha alguma coisa que eu não sabia era só pesquisar sobre o assunto ou perguntar para o pessoal da comunidade, e assim eu conseguia resolver os pequenos probleminhas aos poucos.

Agora que já conhecia um pouco mais e minha experiência tinha aumentado um pouco eu resolvi testar outros Window Managers! Eu queria algo mais leve que o KDE (que eu sempre utilizei), queria algo minimalista, algo simples, curto e grosso, e foi então que eu achei o Fluxbox e descobri que eu poderia ter um Window Manager totalmente configurável, leve, bonito (se você quiser deixá-lo assim) e funcional, portanto defini ele como meu WM principal e ainda uso só o Flux até hoje no Slackware.

Durante o final de 2006 e o meio do ano de 2007 eu utilizei pouco o Linux por 2 motivos:

Devido a ETE que pedia muito coisas de Windows e portanto eu não gostava de ter de ficar trocando de sistema operacional a todo momento.
Comprei um Palm T|X e na época eu estava começando a brincar com o bichinho e usar o Palm Desktop

Nessa época tive um problema e formatei o computador por completo, portanto perdi meu Slackware que estava configuradinho e perdi meus arquivos do Windows, portanto tive que refazer todas as instalações, mas eu estava sem tempo para configurar o Slackware novamente para deixar como eu queria, portanto ele ficou de lado até que eu conseguisse tempo novamente.

Com o fim do meu curso na ETE em julho de 2007, meu tempo retornou e pude voltar a brincar com o Slackware novamente, mesmo trabalhando com tecnologia Microsoft, sempre que eu podia brincar com meu Linux eu brincava, e deixava o Windows para trabalhar e para video game.

Em 2008 eu iniciei meu curso de Sistemas de informação na Fundação Santo André, e nos primeiros dias me vem uma pequena decepção que eu não esperava...As minhas aulas de programação são em VB.net novamente, portanto eu não tenho como fugir do windows por mais 1 ano...E o pior de tudo, pensei que fosse encontrar bem mais pessoas com mente aberta para coisas diferentes, filosofias diferentes, mas não foi bem assim que as coisas de aconteceram...Mas enfim, não é o assunto desse post ;)

Durante esse ano que eu pensei que ia deixar o Linux de lado novamente, mas aconteceram muitas coisas legais, como por exemplo eu mudar de emprego (uhuu!) e agora trabalhar com tecnologia Open Source (uhuuu!)², e portanto eu tenho meu Slackware instalado no computador do trabalho, e comprei um notebook, onde instalei o Ubuntu linux, tanto para conhecer como também para facilitar algumas coisas, assim eu posso conhecer tanto o modo Slackware de fazer as coisas como o modo rápido, fácil e mágico do Ubuntu.

Hoje vivo feliz e contente brincando com meu Slackware e meu Ubuntu, e não preciso mais do Windows para nada além do que é pedido (Visual Studio...) na Faculdade, e isso me deixa muito contente.

No fim das contas o que esse post vem dizer é o seguinte: Se você acha o Linux legal use, persista, conheça coisas diferentes, caso não seja possível nesse momento tudo bem, mas deixe na sua lista de coisas a fazer e assim que possível volte, que você vai descobrindo a quantidade de coisas legais que você pode ter nesse sistema.

Espero que isso tudo seja útil para alguem! ;)

Keep going in the good way!

Montando imagens do Nero (nrg) no Linux

Unknown — Sat, 29 Nov 2008 00:00:00 +0000

Vou comentar agora sobre como montar aquela imagem chata do Nero (.nrg ) que seu amigo que gosta de janelas lhe enviou com aqueles vários arquivos que você tinha pedido... É um hack bem fácil!

Instalações

Primeiro instale o nrg2iso

No Ubuntu

# apt-get install nrg2iso

No Slackware

Baixando o pacote no Linux Packages e instalando normalmente com:

# installpkg nrg2iso-versao.tgz

Utilização

Agora já podemos utilizar o nrg3iso para converter nossa imagem:

$ nrg2iso imagem.nrg novaimagem.iso

E já temos nossa imagem convertida como novaimagem**.iso** e podemos montar nossa imagem normalmente em alguma pasta, como por exemplo /mnt/dirImagemMontada

# mount -o loop -t iso9660 imagem.iso /mnt/dirImagemMontada

E pronto! Lá estarão seus arquivos para você brincar! ;)

Utilizando o sshfs

Unknown — Sat, 29 Nov 2008 00:00:00 +0000

Estou utilizando bastante o sshfs para transferir alguns arquivos para o servidor, ao invés de utilizar o bom e velho scp, por questão de ficar mais prático e facil a cópia de vários arquivos para diretórios distintos.

O que facilita bastante é utilizar a sua chave privada ( explicado por mim nesse tópico) para montar os seus diretórios sshfs, assim você terá o diretório do servidor montado facilmente em seu computador e poderá enviar arquivos para esse diretório e seus sub-diretórios como se estivesse copiando arquivos para outro diretório qualquer.

Instalação

Se você está no Ubuntu as coisas são fáceis e práticas, com o bom e velho apt-get:

# apt-get install sshfs

Agora se você utiliza Slackware temos alguns passos a mais, mas nada que lhe faça arrancar os cabelos ;)

Primeiramente instale o fuse no velho esquema SlackBuilds (ou outro se preferir).

Depois instale o sshfs (dessa vez do Linux Packages para mudar um pouco)

Utilização

Primeiramente temos que subir o módulo do fuse:

# modprobe fuse

Essa tarefa pode ser automátizada posteriormente descomentando esse módulo no /etc/rc.d/rc.modules

E com isso já podemos usar o nosso sshfs! :)

Eu costumo utilizar com os seguintes parâmetros:

sshfs root@server:/local/da/pasta/no/server /local/da/minha/pasta/local -o reconnect,sshfs_sync

E agora é só correr para o abraço e ter o seu diretório do servidor montado localmente para cópia de arquivos.

A facilidade do Ubuntu

Unknown — Sat, 29 Nov 2008 00:00:00 +0000

Deixa eu explicar aqui para quem estou destinando esse post. Esse post é destinado a algumas pessoas que costumam me perguntar se o Linux é difícil, se ele vai conseguir mexer nele se instalar, se Linux é melhor que Windows e outras perguntas derivadas disso, portanto se você já tem conhecimentos em Linux e já usa Linux esse post só vai servir para você passar para seus amigos que não usam, pois é bem básico.

Depois de comprar meu notebook e instalar o Ubuntu nele eu decidi fazer esse post para acabar com aquela idéia das pessoas de que Linux é difícil, que não faz nada, que nada funciona e etc.

Bem, eu sempre gostei de utilizar o Slackware (e ainda é minha distribuição principal) e realmente Slackware não é distribuição Linux para qualquer um...Você não pode dar um Slackware na mão de um usuário final e falar para ele que é fácil, e talvez essa seja a visão que os usuários de Windows tem do Linux.

Estou usando o Ubuntu faz mais ou menos uns 2 ou 3 meses, e muitas vezes já me surpreendi com a facilidade de se fazer as coisas nele! Mesmo um usuário final faria as coisas com uma facilidade espantosa bastando apenas que ele queira conhecer coisas novas.

Alguns Exemplos

Instalando impressora

Estava eu precisando imprimir um documento e já pensei... Configurar a impressora vai ser Punk, mas vou tentar. Procurei nos menus do Gnome e vi um "Printers" em:

System > Administration > Printers

E lá eu clico em "New" ele vai identificar todas as impressoras que você tem na rede e plugadas no seu computador e te mostrar uma lista de drivers para que você escolha qual utilizar.

Ou seja...Não tem dificuldade nenhuma.

Instalando programas

Muitos usuários tem medo do terminal, e alguns se atrevem a dizer que é regredir muitos anos (eles são criativos ;)), mas o terminal te facilita muita coisa em diversas tarefas rapidamente.

Podemos instalar novos programas rapidamente pelo terminal com um simples comando! Digamos que queremos instalar o Inkscape para brincar de fazer uns desenhos vetoriais, é moleza:

$ sudo apt-get install inkscape

Pronto! Ele vai te dar informações sobre o pacote e perguntar se você quer mesmo instalar o pacote que ele mostrou as informações ( caso tenha digitado errado não instalar um pacote qualquer ), e é só responder Y que ele vai instalar e deixar o programa prontinho para usar!

Atualizando a distribuição

Além das atualizações normais que ele faz diariamente (obviamente é facilmente configurável) tambem faz automáticamente as atualizações de distribuição!

Pouco tempo atrás foi lançado o Ubuntu 8.10, e eu como tinha o Ubuntu 8.04, pensei em atulizar, e eis que surge uma atualização de distribuição automáticamente no meu gerenciador de pacotes, perguntando se eu gostaria de ir para a outra versão! :)

Obviamente é um processo demorado, pois são muitos pacotes para atualizar (no meu caso foram mais de 1300), portanto muitos MBs (no meu caso mais de 900) e muitos pacotes para instalar.

Tirando o tempo de download, pois depende muito da sua velocidade de banda, ele instalou todos os pacotes em 20 minutos! E foi só reiniciar (afinal foram mais de 1300 pacotes atualizados) para que eu tivesse as ultimas atualizações da distribuição funcionando no meu notebook.

Interface

A interface do Ubuntu é bem facil de manipular, você pode arrastar atalhos para suas barras, usar alguns efeitos divertidos como deixar as janelas se motimentando como se fossem feitas de gelatina, configurar o que deve e o que não deve aparecer para você no seu menu e etc.

Não se familiarizou com a interface do Ubuntu? Ok, isso pode acontecer, então você pode não usar o Gnome (interface principal do Ubuntu) para usar o KDE (Interface principal do Kubuntu), é só você instalar o Kubuntu ao invés do Ubuntu para que você já tenha uma interface diferente para utilizar.

Aplicativos para escritório

O Ubuntu já vem com ferramentas para suas edições simples, como processador de texto (writter), Planilhas (calc) e criador de Slides para apresentação (presentation) para que você possa fazer suas ações simples de escritório facilmente. Ele tambem traz um aplicativo para você receber todos os seus e-mails no seu computador e poder lê-los offline após baixar (evolution).

O Ubuntu já traz por padrão um aplicativo de Lista de taferas (todo list) para que você possa gerenciar suas tarefas facilmente e se organizar melhor.

Lembrando que esses são apenas os aplicativos nativos, mas você pode instalar facilmente outros programar para Linux com um simples sudo apt-get install ;)

Vídeos e musicas

Você pode facilmente ouvir suas musicas e ver seus vídeos preferidos no Linux usando alguns programas a parte como o amarok e o gxine ou o mplayer, apenas usando o seu padrão apt-get install para instalar, nada de sair procurando aplicativos, baixando e depois instalando. ;)

Você provavelmente vai precisar de uns plugins para assistir os seus vídeos dependendo do formato deles e isso depende do seu player e do tipo de vídeo, mas nada muito difícil de se conseguir! =)

Internet

O que você usa está na internet? Você usa o internet explorer no seu sistema? Saia do lado negro pelo amor de Deus! :P

O Ubuntu já vem com o Firefox instalado e é tudo facinho para utilizar. Você pode acessar a grande maioria dos sites da internet normalmente, e se por um acaso você encontrar um site que você não consiga navegar com o FIrefox você pode usar a

extensão User Agent Switcher do Firefox e ele vai renderizar a página como se fosse um internet explorer para que você possa navegar. Mas se isso realmente acontecer faça um favor para toda a internet e envie um e-mail para o criador desse site reclamando dos seus problemas, pois pelo visto ele não está nem pensando em muitas pessoas.

Precisa usar o MSN? Moleza! Só usar o Kopete, o Pidgin, o aMSN ou qualquer um dos outros vários que tem para esse serviço! Mas...Quer uma dica? Use outros serviços bem mais interessantes como o do Gtalk (que pode ser configurado no Pidgin e no Kopete) ou até mesmo o Skype (que pode ser instalado com apt-get install :P )

Fotos

Quer manusear suas fotos, fazer modificações, disponibilizar elas na internet? Isso é tudo moleza no Ubuntu!

Se você gosta de ter um programa para gerenciar suas fotos, criar alguns, colocar tags, fazer upload para a internet e mais um monte de coisas, é só usar o Picasa (adivinha como instalar ele? Sim! apt-get install) que é um das dezenas de serviços do Google e portanto fica vinculado com a sua conta do Google (Gmail, Orkut ou outros) e suas fotos ficam na internet se você quiser , pois podem ficar apenas no seu computador tambem.

Tirou uma foto e ela não ficou legal? Basta dar uma pequena alterada usando o GIMP, que é um manipulador de imagens bem interessante para se conhecer, e é claro que é gratuito e Open Souce. ( preciso dizer que é facil de instalar? )

Jogos

Esse tópico é um pouco contraditório com o que você deve estar esperando, pois você não vai encontrar o seu

GTA San Andreas, The Sims, Spore (ou seja lá o que for que você jogue em outro sistema operacional) em versão oficial para Linux. Até podem existir versões portadas dos seus jogos para Linux ou utilizando Wine (pode ser baixado por apt-get para variar um pouco) que roda programas de Windows no Linux, mas o Wine ainda não está perfeito e não vai ser qualquer jogo que vai rodar facilmente com ele...:/

Em compensação o Linux tem alguns jogos nativos que são legais, obviamente não tanto quando outros jogos e não em maior quantidade, mas eles existem! :)

Tem um post muito legal no Techforce que fala de alguns modos para rodar jogos no Linux, alguns jogos que tem versão para Linux e outras coisas bem interessantes.

Se você é um gamer que seu computador se tornou um vídeo game, agora ainda não é seu momento com Linux, mas quem sabe ele virá! ;)

Bem...Tentei mostrar acima muitas coisas simples que as pessoas utilizam e podem fazer normalmente (e facilmente) no Linux, apenas para mostrar que o Linux tem ferramentas para você fazer as coisas e tem coisas interessantes, mas ainda precisamos assumir essa mudança de paradigma e mudança de conceito para decidirmos aprender mais coisas e ver como é legal outras coisas que nem lhe passavam pela cabeça que existiam.

Se tiverem alguma dúvida é só postar nos comentários, que farei o possível para responder.

Deixando seu ssh mais facil de trabalhar

Unknown — Thu, 27 Nov 2008 00:00:00 +0000

Se você usa bastante SSH vou mostrar um método para facilitar um pouco a sua vida. Sei que existem métodos melhores para trabalhar com vários SSH ao mesmo tempo, geralmente a galera que administra vários servidores costuma usar screen para se manter conectado, mas eu como conecto de vez em quando para ver algo em algum dos servidores prefiro configurar desse modo.

A primeira coisa a se fazer é configurar o seu .ssh/config

Host server
Hostname 192.168.1.2
User pothix
ForwardAgent yes

Sendo que Host é o que você vai usar quando for chamar por ssh (por exemplo "ssh server"), Hostname é o IP do server, User é o usuário no servidor e ForwardAgent para usar o nosso ssh-agent.

Tem um totorial bem legal sobre configuração de SSH no guia do Hardware que explica algumas opções.

Vamos agora configurar o nosso ssh-agent, que é um agente de autenticação que gerencia as nossas conexões ssh na sua seção de terminal.

Primeiramente você deve iniciar o seu ssh-agent:

$ eval -s `ssh-agent -s`

Isso via iniciar o seu ssh-agent e já definir as variáveis de ambiente que ele precisa para funcionar na sua instancia atual do terminal.

Agora que já temos o nosso ssh-agent funcionando, vamos criar a nossa chave privada para utilizar:

$ cd ~/.ssh
$ ssh-keygen -t rsa -f minha-chave

Com isso ele pedirá a a senha para sua chave e depois de você digitar e confirmar ele criará dois arquivos de chave:

minha-chave
minha-chave.pub

O arquivo minha-chave é o arquivo que vamos usar para facilitar a nossa vida, e o arquivo minha-chave.pub é o arquivo publico de identificação da sua chave, falaremos mais disso depois.

Agora com nossa chave em mãos já podemos acrescentar ela no nosso ssh-agent, utiliando o ssh-add:

$ ssh-add ~/.ssh/minha-chave

Ele vai pedir a senha da sua chave e depois vai adicionar ela no ssh-agent e agora é só alegria! :)

Agora vamos acessar o servidor que cadastramos no nosso ~/.ssh/config

$ ssh server

Lembra dele, que fizemos lá em cima? Pois é agora vamos acessar ele sem precisar ficar digitando a senha toda vez, apenas usando a nossa chave! :D

Lembrando que tem um porém! Isso só vai funcionar se nós estivermos autorizados a acessar o servidor sem senha, utilizando a chave, e para isso temos que ter o conteúdo do nosso minha-chave.pub no $HOME/.ssh/authorized_keys do servidor, e o problema está resolvido! :)

Isso para mim é uma mão na roda, e espero que seja para vocês tambem. ;)

Ativando numlock na Inicialização do Fluxbox no Slackware

Unknown — Thu, 13 Nov 2008 00:00:00 +0000

Estava eu pesquisando na internet como conseguir fazer o meu numlock já iniciar ativado quando meu fluxbox inicia e encontrei várias dicas, sendo umas para XFCE e outros sistemas não sendo Slackware, portanto decidi escrever como fiz no Slackware.

Primeiramente precisamos do numlockx que é o programinha vai ativar o num facilmente.

Podemos instalar ele via SlackBuilds que eu uso muito!

Após baixar o numlockx.tar.gz e o numlockx-.version.tar.gz` vamos seguir os procedimentos do SlackBuilds:

$ tar xvf numlockx.tar.gz
$ mv numlockx-version.tar.gz numlockx
$ cd numlockx
# ./numlockx.SlackBuilds

Pronto! Seu pacote já está no seu /tmp! :)

Agora só instalar com o pkgtool:

#installpkg numlockx.tgz

Agora é só inserir a seguinte linha no seu ~/.xinitrc:

exec numlockx &amp;</code>

E da próxima vez que inicar o seu Slack seu num vai acender automágicamente! :P

Facilitando a instalação de pacotes no Slackware

Unknown — Tue, 11 Nov 2008 00:00:00 +0000

Estava escrevendo outro post e chegando em um ponto onde eu instalaria um pequeno Software utilizando o SlackBuilds me fez escrever esse post sobre algumas facilitações de instalação para Slackware.

Nesse post eu vou referenciar 4 facilitadores para instalação de pacotes no Slackware: SlackBuilds, LinuxPackages, Slackpkg, Slapt-get e Checkinstall.

SlackBuilds

Primeiramente vou comentar sobre um dos que eu mais uso e que mudou a minha vida ( heheh ), que é o SlackBuilds!

SlackBuilds são scripts que facilitam a instalação de softwares diretamente pelo seu fonte, ao invés de usarmos o velho ./configure && make && make install.

Quando eu preciso instalar algo, o primeiro lugar que eu visito é o site do SlackBuilds para procurar se tem o que eu estou procurando, depois procuro em outro lugar.

Para usar o SlackBuilds é simples!

Primeiro você encontra o seu pacote no site.
Agora você faz o download do pacote do SlackBuilds, que geralmente está no formato nomeDoPacote.tar.gz
E faz o download do source do que você vai instalar, que geralmente está no formato: nomeDoPacote-versao.tar.gz
Agora você descompacta o seu pacote SlackBuilds da forma tradicional: tar xvf nomeDoPacote.tar.gz
Agora ele criou uma pasta do seu SlackBuilds com o nome de nomeDoPacote.
copie os fontes para a pasta do seu SlackBuilds: cp nomeDoPacote-versao.tar.gz nomeDoPacote
Agora entre na pasta do seu SlackBuilds: cd nomeDoPacote
E como root execute o seu arquivo de SlackBuilds: ./nomeDoPacote.SlackBuilds
Se tudo der certo nesse passo (pode ser que tenha alguma dependência, o que fará você tentar novamente o passo 1 para a dependência) ele vai compilar tudo para você e vai gerar um pacote .tgz do Slackware no seu /tmp ! :)
Agora é só correr para o abraço! Acessar o seu /tmp e instalar o pacote com o bom e velho installpkg

Linux Packages

Como segunda opção para facilitar a instalação no Slackware temos o Linux Packages que tem muitos pacotes tgz para você baixar e instalar facilmente com o gerenciador de pacotes do Slackware.

Slackpkg

Para instalações mais automatizadas temos também o Slackpkg que foi criado pelo Piter Punk como um script para atualização de pacotes mais facilmente quando surgiam exploits ou bugs, e acabou se extendendo a instalação de pacotes e outras features interessantes.

Eu utilizo o Slackpkg para atualizar pacotes e para instalar pacotes padrão da distro, e para isso é muito bom, mas não pense que ele vai instalar aquele pacote xyz que você estava procurando, pois ele não é um apt-get.

Slapt-get

Slapt-get (pode-se fazer o download no Linux Packages), esse sim tenta ser um apt-get! Ele faz quase as mesmas coisas que o apt-get faz, mas não resolve dependencias.

Ele tambem tem um arquivo de mirrors que fica localizado em /etc/slapt-get/slapt-getrc. E em termos de comandos não muda muito do apt-get, e você pode usar o slapt-get --install nomeDoPrograma ou slapt-get --update.

Checkinstall

O checkinstall é utilizado para quando você estiver instalando um programa a partir do seu fonte você possa gerar um pacote da sua distribuição no final da instalação e instalar por ele, assim você terá mais controle pelo seu gerenciador de pacotes e tambem para que da próxima vez seja mais fácil instalá-lo.

A instalação segue padrão até o momento final:

$ ./configure
$ make

E agora ao invés do nosso # make install usaremos:

# checkinstall -S

E assim ele vai criar um pacote Slackware no diretório e instalar. :)

Bem isso é só para dar uma idéia do que se pode fazer para deixar suas instalações do Slackware mais rápidas.

Aprenda Ruby no Rubylearning

Unknown — Fri, 07 Nov 2008 00:00:00 +0000

Como muitos sabem, eu sou um dos professores assistentes do Rubylearning.org que oferece gratuitamente cursos de ruby!

O Satish Talim anunciou que estão abertas as inscrições para o FORPC101-9C ( Free Online Ruby Programming Course 101 - Batch 9 Core) que é a série de cursos gratuitos sobre Ruby Core.

Aconselho todos que querem aprender Ruby a participarem! Não se preocupe muito com seu inglês, ele não precisa estar extremamente afiado para você participar, basta que você consiga entender bem para que você participe, e caso não consiga escrever bem o pessoal pode ajudar você a se expressar para conseguir ajuda nos Foruns!

Eu (assim como muitos) recomendo! E estarei por lá para dar uma força a quem precisar.

Para quem se interessar, o Rubylearning tambem oferece alguns cursos pagos (seguindo a mesma linha dos gratuitos):

POIRPWDC101-1I: Paid Online Intermediate Ruby Programming With Database Course

Como o nome mesmo diz, é um curso intermediário de Ruby voltado a banco de dados! É um curso pequeno tendo como conteúdo FXRuby, YAML e Active Record com MySql!

POIRPWSC101-1I: Paid Online Intermediate Ruby Programming With Shoes Course

Esse é um curso que terá como mentor o Satoshi Asakawa e terá o como conteúdo uma introdução ao Shoes com exemplos e exercícios para fazer! O Satoshi está indo longe com o Shoes e foi até citado pelo _why!

POIRPC101: Paid Online Intermediate Ruby Programming Course

Curso intermediário de Ruby, sendo o conteúdo: YAML, FXRuby, Unit Testing, Socket Programming e Threads.

POJRPC101: Paid Online JRuby Programming Course

Curso abordando um pouco sobre JRuby, mostrando como usar o Jruby em si, como usar as Classes Java, Programadores Java usando Classes Ruby e ActiveRecord com JDBC.

Não se preocupem com os preços dos cursos do Rubylearning, pois são valores simbólicos, geralmente o Satish cobra entre 5 a 10 dólares pelo PayPal, portanto vale a pena para se manter conectado com o pessoal que está aprendendo, tendo acesso a material, a fórum e etc.

Os cursos realmente valem a pena! Caso não queira fazer os cursos pagos então faça ao menos o gratuito sobre o Core que é muito útil para conhecer mais sobre o Ruby, e se gostar pode pensar nos pagos.

Rails Summit Latin America (Day 2)

Unknown — Wed, 22 Oct 2008 00:00:00 +0000

Para quem não viu o meu post sobre o primeiro dia da Rails Summit, veja aqui! ;) E agora vamos ao segundo post sobre a Rails Summit! :)

Começamos o segundo dia de Rails Summit as 8:00, e logo no começo do dia tivemos alguns probleminhas técnicos com energia elétrica que logo foi contornado com um gerador ( esse evento escala! ). Tivemos a abertura do dia com o Fabio akita comentando sobre as palestras e dando recados gerais.

A primeira palestra foi dos caras da Phusion, Hong Li Lai e Ninh Bui, que deram uma palestra muito engraçada e explicativa sobre o Phusion Passenger.

Eles usaram animações, brincadeiras com a foto do Fabio Akita o que deixou a palestra muito divertida de ser acompanhada. Também comentaram sobre como é programar em Rails com várias brincadeiras com outras linguagens ( cofPHPcof ), comentaram sobre escalabilidade e outras coisas bem interessantes.

Tudo isso fora o Ninh Bui vestido de Darth Vader. :D

Após isso tivemos a palestra por vídeo conferência do Charles Nutter e do Thomas Enebo sobre Jruby.

Infelizmente tivemos alguns problemas técnicos de conexão o que deixou o nosso audio com um pouco de lag, e cortava um pouco a voz dependendo do momento, e isso fez com que minha atenção se dispersasse a todo momento, portanto não tenho muitos comentários para fazer sobre essa palestra. Mas foi bem interessante, com direito a um pequeno joguinho com OpenGl rodando.

A partir daqui começa o momento test no Rails Summit, pois a grande maioria das palestras são sobre tests, o que não é nada mal! :)

Primeiro temos a palestra do Jay Fields sobre tests e selenium, onde ele fala bastante sobre a importancia dos tests para se proteger de antigos bugs que podem voltar ou novos bugs que podem aparecer quando se implementam novas features. Ele comenta um pouco sobre selenium e outras coisas...Eu recomendo o post do Sylvestre Mergulhão sobre essa palestra.

Agora temos duas palestras consecutivas do David Chelimsky (mantenedor do Rspec) no auditório principal enquanto na outra sala temos Manuel Lemos e Vinucius Teles palestrando sobre "Os desafios de criar um caso de sucesso no Brasil" e "Empreendedorismo com RubyOnRails" respectivamente. Tinha que escolher novamente e preferi escolher as palestrar sobre testes e assisti as 2 do Chelimsky

O Chelimsky tem uma namorada brasileira, portanto ele consegue falar um pouco de português, mas ele decidiu dar a palestra em inglês por não ter fluência. Na primeira palestra tivemos o conceito de BDD, onde você escreve primeiramente os seus testes e eles vão "te lembrando" como continuar escrevendo o seu código. Os exemplos dados pelo Chelimsky foram bem didáticos e interessantes. Vimos User Stories, e uns exemplos na pratica utilizando Rspec. Foi passado um "conceito" de como fazer testes: Escrever um teste que falha, fazer o teste passar, refatorar o código procurando pelos famosos "Maus cheiros". Já na segunda palestra ele extendeu a primeira e agora começou a falar mais sobre o cucumber, que parece muito interessante para usar!

Para mudar um pouco eu resolvi ir numa palestra sobre testes ( hehe ) dessa vez foi a palestra do Danilo Sato sobre "testes automatizados - TDD", onde ele mostrou algumas ferramentas e deu algumas dicas sobre como ele começou com testes, sobre dificuldades, vantagens de testar, alguns problemas que você pode se deparar e possíveis soluções para os mesmos, comentou sobre os "maus cheiros" dos testes, fez algumas recomendações bibliográficas interessante alem de comentar tambem sobre MOCK e Synthesis tambem.

Agora tivemos a palestra do Luis Lavena que é o criador do One-click-installer para windows, que veio falar sobre produtividade trabalhando em rails com windows e outras questões tendo o windows como base.

Enquanto isso tínhamos uma palestra sobre Jruby com o Fabio Kung na outra sala.

Nesse momento eu decidi não participar de nenhuma das duas e fiquei conversando com os Railers que estavam reunidos lá fora prontos para gravar um vídeo-cast que no fim das contas após mais de 30 minutos de "gravação" descobrimos que não estava gravando, portanto a única parte do vídeo que temos é a apresentação da galera. ¬¬ Mesmo com esse pequeno problema com a não gravação do vídeo, foi muito interessante interagir com os Railers e conhecer pessoalmente toda essa galera que eu só conhecia por nickname ou e-mail.

Tivemos agora uma propaganda da Sun (que é um dos patrocinadores do evento) sobre Open Souce comentando sobre a plataforma Java, OpenSolaris e outras questões ligadas a Open Souce, que não deixou de ser interessante! :)

Chegamos ao momento da ultima palestra do evento, dada pelo Obie Fernandez (que lembra bastante o Jack Black nas fotos), que foi muito interessante !!

O Obie comentou sobre a HashRocket e seus meios de trabalho. Explicou os métodos de desenvolvimento ágil que eles utilizam, como funcionam os seus meios de negócio, seus meios de contratação e suas diversões!

Achei muito interessante o meio que ele diz usar para contratar, que é chamar a pessoa para trabalhar na empresa por uma semana e assim descobrir se ela é boa mesmo para trabalhar lá ou não. Achei muito interessante e gostaria que coisas desse tipo tambem funcionasse aqui no Brasil, mas infelizmente as coisas são bem diferentes por aqui, tanto por questões contratuais como por outras questões tambem.

Outra coisa que ele comentou que eu achei muito interessante foi o enfoque em se divertir apesar de estar no trabalho, estamos fazendo o que gostamos e temos que ter bons momentos! Achei legal as fotos das festas com todo mundo pulando na piscina e tal, acho que isso que realmente faz uma equipe motivada!

Realmente o Obie fechou com chave de ouro o Rails Summit 2008! :)

Considerações final da Rails Summit

O evento terminou rendendo um projeto no GitHub que já tem várias contribuições! :P

Espero que seja o primeiro de muitos e que eu possa estar presente em todos os subsequentes!

Meus parabéns ao Fabio akita que foi o organizador principal do evento e correu bastante para que tudo isso se tornasse realidade! E parabens a Locaweb por contribuir para esse projeto!

Rails Summit Latin America

Unknown — Tue, 21 Oct 2008 00:00:00 +0000

Como muitos sabem eu participei da Rails Summit Latin America e vou agora fazer uns comentários sobre o evento.

Vou dividir em 2 posts, um para cada dia, por que o assunto ficou bem extenso.

Minha intenção com a Rails Summit, alem de ver as ótimas palestras era de fazer um social network com a galera que eu só conhecia por nickname, e isso realmente foi difícil de fazer justamente por isso, reconhecer as pessoas pessoalmente sendo que só as conheço por nickname e avatar não é nada fácil.

Fazendo um pequeno resumo do pessoal que eu queria encontrar e encontrei:

Marcos Ricardo Que tambem é um dos professores assistentes do Rubylearning.org junto comigo, e só o conhecia pelos foruns do Rubylearning. Essa foi uma grande oportunidade de conhecê-lo pessoalmente, além de poder tirar fotos com ele e com o Akita para enviar para o Satish Talim

Dirs e Mauricio Dois funcionários da Boo-box que eu conhecia por nome e trabalham aqui perto de mim ( teodoro sampaio ), que por sinal são muito gente boa! =)

Arthur Zaparolli (arthurgeek) Conhecia por nome, já troquei e-mail com ele e foi mais um dos contatos que passaram a existir fisicamente! =)

Julio Monteiro (responsável pelo rubyonrails.pro.br), Davis Cabral e Ozeias Santana (responsáveis pelo podcast Railsbox) Figuras do mundo Rails que só conhecia por nome e foi interessante conhecê-los pessoalmente! Galera bem divertida!

TaQ Um figurão que eu conversava pela internet já faz um tempo e tive a oportunidade de conversar com ele um pouco! Tenho um estilo bem parecido com o desse cara...hahaha...Será que eu vou ser como ele qunado crescer? hahahahaha

Fabio Akita Já tinha conversado com o Fabio no Google Developers Day e tive a oportunidade de conversar um pouco com ele na Rails Summit tambem, apesar de que ele estava bem apressado com a quantidade de coisas que tinha que se preocupar. :)

Carlos Brando Conversei bem pouco, mas foi interessante conhecer mais um dos caras influentes no Brasil e responsável (junto com o Akita) pelo Rails Podcast Brasil.

Pessoal do Aprendendo Rails: Elomar França, Raul Souza Lima (Nihil), Juarez Filho, William Paixão, Thiago Freire Essa galera eu já tive contato pelo aprendendo-rails e estava querendo conhecê-los pessoalmente já faz um tempo. Elomar França realmente se revelou como um dos grandes palestrantes da Rails Summit, falando sobre Grupos de discussão e aprendizado, onde comentou sobre o aprendendo-rails, o +web e outros grupos no gênero. Com muito humor e irreverência conseguiu mostrar para a galera que grupos é uma ótima forma de aprender... Parabéns Elomar! Raul tambem é de outro grupo que eu participo que é o ruby-sp, mas eu gostaria de ver mais gente do grupo por lá. **

OBS: Só depois eu fiquei sabendo que o Hugo tambem estava lá! ¬¬ Provavelmente eu esqueci alguem, mas com certeza eu não vou conseguir lembrar de todo mundo! ;)

Bem passando agora por essa parte de pessoal, vamos as palestras e reviews do evento em si:

Começamos com uma abertura do Fabio Akita e Gilberto Mautner (fundador da locaweb) comentando sobre o evento, as soluçoes da locaweb, como ela começou e tudo mais. Foi interessante para conhecer um pouco mais sobre a locaweb e viajar no tempo vendo o primeiro site deles...hehe

Deveriamos começar com o Chad Fowler, mas devido a alguns problemas de horários do David Heinemeier Hansoon, a conversa com ele por vídeo conferencia foi adiantada e começamos com ele antes. Tivemos uma conversa com O DHH (pois não foi bem uma palestra), onde ele comentou sobre as novas features do Rails e ficou aberto a perguntas do pessoal, que eram traduzidas para o ingles se necessário pelo Fabio Akita. Surgiram algumas perguntas quanto a thread safe nativo do Rails 2.2, como ficariam as questões de internacionalização quanto aos campos com "ç" e acentos, e todas foram bem respondidas pelo DHH. Foi interessante ter a oportunidade de conversar sobre o futuro do Rails.

Após isso tivemos a palestra do Chad Fowler ( que por sinal está bem diferente da foto dele que colocaram na chamada do evento....hehe ), que foi muito interessante!

Ele falou sobre ser "remarkable", fez várias comparações com a musica, o que trazia um bom dinâmismo a palestra. Achei muito interessante a colocação dele quando mencionou os níveis de programadores: Iniciante, iniciante avançado, avançado e expert. Ele disse que mais de 50% dos programadores ficam na parte de iniciante avançado e não buscam ir mais a fundo em sua área de desenvolvimento para realmente ter um conhecimento mais amplo e profundo sobre o que ele está lidando. O Chad tambem comenta sobre projetos Open Source, dizendo para você ser crítico e reportar o que você vê de errado nos softwares, e melhor do que isso, como temos todo o código em mãos, podemos contribuir para o que não gostamos e tornar assim o software melhor.

Na próxima palestra George Malamidis e Danilo Sato falariam sobre REST e após assistir o comecinho da palestra eu decidi ver a palestra do Fabio Akita, que ia apresentar o Rails para iniciantes criando uma pequena aplicação e tudo mais. A palestra foi bem tranquila assim como todas as palestras de apresentação do Rails com criação de um pequeno blog e tudo mais, mas achei interessante que ele conseguiu demonstrar o uso de plugins, e nesse caso ele utilizou o active_scaffold, e foi bem interessante mostrar o que o Rails pode fazer rapidamente com plugins.

Terminando a palestra do Akita, enquanto entram na sala o pessoal da SurgeWorks, que participariam da palestra do Carlos Brando com o tema "Meu emprego foi para os EUA", o Dr. Nic Williams estava começando sua palestra no auditório principal...

Tinha uma escolha difícil de palestras para fazer, e no fim das contas decidi assistir a palestra do Carlos, que desde quando ele anunciou o assunto já me interessei.

A palestra foi bem interessante, e ele comentou por que o trabalho dos brasileiros é bem cotado lá fora, e como se tornar um bom profissional para ser contratado, não ser apenas generalista ou apenas especialista, e sim ser um pouco dos dois, se especializando em algo mas não deixando de lado outras coisas, criar seu blog e escrever sobre um determinado assunto para mostrar que você existe e está ali publicando bom conteúdo, e mostrar seu código para que ele possa ser avaliado pelas pessoas que possam querer quem sabe lhe contratar.

Além da palestra em si, tivemos um momento muito interessante, que foi a seção de perguntas e respostas com o pessoal da SurgeWorks, onde toda a equipe poderia responder perguntas sobre como é trabalhar para uma empresa do exterior, e o Carl respondendo como empregador.

Surgiram perguntas muito interessantes que atormentavam muitas pessoas até hoje. As mais interessantes para mim foram essas:

Como receber

Primeiramente é bem recomendável receber como pessoa jurídica, pois pessoa física paga muitos impostos. Funciona da seguinte maneira (se estiver errado comente que eu edito, estou fazendo baseado em algumas anotações minhas sobre a palestra):

A empresa passa para o banco do brasil de lá
O dinheiro é transferido para o banco do brasil daqui ainda em dólar
Eles entram em contato com o setor cambial do banco para fechar a negociação da taxa de conversão
Depois disso o dinheiro cai na sua conta

Faculdade é importante?

Essa pergunta foi feita para o Carl e isso me serviu bastante pois tambem tenho essa dúvida. Carl respondeu que faculdade não é tudo, mas é um diferencial, pois muita coisa não dá para aprender se não tiver um professor ali te forçando a estudar, ou você nunca buscaria isso se realmente não fosse realmente necessário. Nessa pergunta surgiu uma frase que resume tudo e deixa lição para muitos alunos de faculdade:

Bons programadores se formam, mas faculdade não forma grandes programadores

Agora é a hora do Keynote do Chris Wanstrath, que pareceu um pouco nervoso, e eu não tenho muito o que comentar pois pode ser lido no keynote dele. (obrigado pelo link Dirceu).

Agora temos uma das partes mais divertidas do evento, que foi o momento desconferência, que foi nomeado "Birds of Feather". Infelizmente não vou lembrar o nome de toda a galera que apresentou algo na parte de Birds of Feather, mas se você apresentou, ou souber quem apresentou, por favor comente! =)

Tivemos vários assuntos de todos os gostos: interessantes, curiosos, informativos, engraçados e etc...

Um que achei bem interessante foi sobre um projeto de impressora fiscal feito em Ruby, que não era web e sim desktop utiliando GTK ( quase certeza ), mas achei bem legal o conceito.
Outro que achei curioso foi o projeto do Ninh Bui (Phusion) que é um "compilador Brainfuck > ruby" que pega um código brainfuck, transforma em ruby e executa....haha
Outro projeto interessante que foi apresentado pelo cara do pagestacker (desculpa não lembrar seu nome) foi o footnotes-debug que é utilizado para ajudar no debug de aplicações rails. Ele cria um pequeno footer na sua página com vários links úteis para o debug, como: mostrar cookies, abrir código (apenas para Mac com textmate) e outras coisas que não me lembro de momento.
Um projeto que me animou bastante foi o projeto apresentado pelo demetrius nunes sobre GOSU para programação de jogos em Ruby! Sempre tive vontade de desenvolver jogos, e já ouço falar de Python para isso faz um tempo, mas não conhecia nada até entao para brincar com Ruby, portanto me deixou bem animado.
O Silvestre Mergulhao apresentou um projeto bem interessante de uso de bluetooth com Ruby e me atraiu bastante a atenção tambem pois bluetooth está na minha lista de coisas para brincar. ;)
E para fechar com chave de ouro meus comentários sobre o Birds of Feather, temos o Elomar França que falou sobre grupos de estudo. Com certeza o Elomar foi a grande revelaçao do Rails Summit, pois ele conseguiu apresentar de uma maneira bem divertida como os grupos de discussão podem ajudar no seu aprendizado, assim citando o +web que é o grupo que ele cordena na sua cidade, e o aprendendo-rails que é o grupo que ele participa cuja finalidade com ele mesmo diz "é bem fácil de se notar....aprender rails".

Bem....E assim acaba o primeiro dia de Rails Summit! Estou terminando um post sobre o segundo dia e publicarei daqui a um ou dois dias. :)

Enquanto isso vocês podem ver os posts dos das pessoas que citei, pois quase todos eles postaram várias informações em seus blogs. Destaque para o Silvestre Mergulhao e o Fabio Akita que postaram muita coisa interessante.

Para quem quiser ver fotos eu coloquei todas as minhas no meu Picasa.

Primeiro post por aqui!

Unknown — Tue, 02 Sep 2008 00:00:00 +0000

Bem, como primeiro post vou me apresentar e dizer qual o meu intuito com esse blog.

Lembro muito bem da época que associava blog com os "flogão" da vida e prometia para mim mesmo que eu nunca criaria um blog para mim. Com a mudança de rumo dos blogs a minha vontade de criar um para divulgar informação útil foi crescendo, mas eu me mantinha preso aquela velha promessa, até que mês passado eu consegui me livrar disso e decidi finalmente ingressar no ramo de blog, pois eu pesquiso e leio tanta coisa que provavelmente algum dos conhecimentos que tenho ou coisas que fiz serão úteis para mais alguem.

O foco desse blog é principalmente compartilhar informações úteis sobre desenvolvimento, Linux e eventos de tecnologia, mas de vez em quando postarei algumas coisas de Nerd para não perder o costume. ;)

Acho que já está bom para um primeiro post, não!?

Se quiser mais informações sobre mim procure na seção sobre do site.