So… Why not?

However, while gems and libraries can offer many benefits, there are compelling reasons to exercise caution and minimize their usage in favor of keeping code within the repository.

Version Incompatibilities

One of the foremost concerns when relying heavily on external gems and libraries is the risk of version incompatibilities. As Rails and its associated gems evolve, newer versions may introduce breaking changes or conflicts with existing code. This can lead to painstaking troubleshooting, dependency resolution, and potential downtime. By minimizing external dependencies, developers can mitigate the risk of version conflicts and maintain greater control over their codebase’s stability.

I ran into a problem like this recently: I was working on an application that was many years old with an outdated version of Rails and Ruby. Many gems were old and needed to be updated. What happened was that one of the gems needed to be updated anyway because it was integrated with a third party service. To be able to carry out the update, it was necessary to update several other gems together, causing uncertainty as to whether everything would work out. Good thing we had acceptable test coverage and a wonderful QA team.

Code Maintenance

Every gem or library added to a Rails project represents another piece of code that must be monitored, updated, and maintained. As time passes, maintaining compatibility with evolving dependencies becomes increasingly challenging, particularly if certain gems fall out of active development or lack adequate documentation. By keeping code within the repository, developers can simplify maintenance efforts, ensuring that all components of the application remain up-to-date and cohesive.

In the same code mentioned above we have several challenges that for now are just technical debts but that at an inopportune moment we will have to deal with. For example, this application is using a gem that is already deprecated, when we need to update another gem that it depends on, we will need to modify all the code where it is used to place a replacement. That time will come, one way or another.

Security Risks

External dependencies can introduce security vulnerabilities into an application. While reputable gems are typically maintained with security best practices in mind, vulnerabilities may still arise, especially in lesser-known or unmaintained libraries. By minimizing the number of external dependencies, developers reduce the attack surface and can more effectively implement security measures tailored to their specific application.

At the same time, we are targets of hackers who can deliberately add backdoors and malicious codes to the packages downloaded for our applications. The media has already recorded several cases of security breaches in libraries, mainly from NPM. But RubyGems is also not safe from malicious code insertion.

Performance Overhead and Dependency Bloat

Every gem/library included in a Rails project incurs a performance overhead, however minor. While individual performance impacts may seem negligible, they can accumulate over time, particularly in large-scale applications with numerous dependencies. Minimizing external dependencies allows developers to optimize performance by reducing unnecessary overhead and streamlining the application’s execution.

Over-reliance on gems/libraries can lead to dependency bloat, wherein a Rails project becomes burdened with an excessive number of external dependencies. This can impede development agility, increase deployment complexity, and hinder scalability. By prioritizing self-contained code within the repository, developers can maintain a leaner, more manageable codebase that is easier to maintain and scale over time.

Practices

The author of the book Sustainable Web Development with Ruby on Rails, David Copeland, suggests that we should update dependencies Early and Often. His advice is to define one day per month for dependencies to be updated. In other words: “we’d run bundle update in our Rails apps, run the tests, fix what was broken, and then be up to date” (page 380). Another piece of advice from the author is to keep a Versioning Policy and Automate Dependecy Updates.

Another good way to be prepared for package updates, in addition to using minimal libraries, is to have good automated test coverage. And never forget integrity testing!

I worked on a system whose Ruby was on version 2.6.7 and needed to be updated to at least the next version because it was hosted on Heroku and the container that worked with this version would no longer be supported in 2 months (and in a few months more it would no longer be available for deployment). At the time I joined this project there was not one line of test written, and we didn’t have a QA team yet. It took 2 complicated months to write a minimum of test coverage so that we would be able to carry out the version update the Ruby and Rails versions with more confidence.

Conclusion

While gems/libraries undoubtedly offer valuable functionality and convenience in Ruby on Rails development, their indiscriminate usage can introduce numerous challenges and risks. By prioritizing self-contained code within the repository, developers can minimize version incompatibilities, simplify maintenance efforts, mitigate security risks, optimize performance, and avoid dependency bloat. Ultimately, exercising restraint in the adoption of external dependencies promotes greater code stability, security, and maintainability, ensuring the long-term success of Rails applications.

Sequence IDs: Embracing Predictability and Efficiency

This is the easiest option to implement as it is the one available in most cases. When we create a new model or generate a scaffold, the Sequence ID is already the established standard. Sequence IDs maintain a predictable numerical sequence, facilitating database operations like range queries and indexing.

Advantages

1. Sequentiality: Sequence IDs maintain a predictable numerical sequence, facilitating database operations like range queries and indexing.
2. Simplicity: Sequence IDs align with conventional database practices, requiring minimal configuration or external dependencies.
3. Efficiency: Sequential IDs promote efficient database indexing and storage, optimizing performance in certain use cases.

Disadvantages

1. Predictability: Sequential IDs expose database sequence information, potentially enabling attackers to infer patterns or exploit vulnerabilities.
2. Scalability: In distributed environments or high-throughput applications, managing sequential IDs across multiple nodes can pose scalability challenges.
3. Readability: Numeric IDs lack the human-readable qualities of hashed strings, potentially impacting user experience and URL aesthetics.

Potentialities

1. Performance Optimization: Sequence IDs excel in scenarios where sequential access or range queries are prevalent, leveraging database indexing for enhanced performance.
2. Compatibility: Sequence IDs seamlessly integrate with existing database schemas and workflows, minimizing migration efforts and compatibility concerns.

How to do this

You don’t need to do anything beyond the basics. This is already the standard.

UUIDs (Universally Unique Identifiers): Ensuring Global Uniqueness and Interoperability

Universally Unique Identifiers (UUIDs) provide unparalleled guarantees of global uniqueness across distributed systems and time. This decentralized approach to identifier generation alleviates concerns about collision risks, making UUIDs ideal for large-scale deployments and decentralized architectures. However, the very long IDs and the lack of connection with more human information end up making their use difficult. It is a good option for those who have distributed databases or want to merge databases. I wouldn’t use it if I didn’t have one of these reasons.

Advantages

1. Uniqueness: UUIDs guarantee global uniqueness across distributed systems and time, mitigating collision risks even in large-scale deployments.
2. Decentralization: UUIDs can be generated without centralized coordination, making them suitable for decentralized or distributed architectures.
3. Standardization: UUIDs adhere to established standards like RFC 4122, ensuring interoperability and compatibility across platforms and frameworks.

Disadvantages

1. Length: UUIDs are longer than sequential or hashed IDs, potentially impacting database storage and network transmission overhead.
2. Readability: UUIDs lack human-friendly qualities, often appearing as random strings of characters, which can diminish URL aesthetics and user experience.
3. Indexing Complexity: Indexing UUIDs in databases may incur performance penalties due to increased storage requirements and index fragmentation.

Potentialities

1. Global Uniqueness: UUIDs provide unparalleled uniqueness guarantees, making them ideal for scenarios where collision avoidance is paramount.
2. Decentralized Generation: UUIDs facilitate distributed system architectures by enabling decentralized ID generation without centralized coordination.
3. Interoperability: Standardized UUID formats promote interoperability and compatibility across diverse platforms, frameworks, and technologies.

How to do this

You’ve probably already come across several articles explaining how to use UUID in Rails so I’ll just put the summary version. So far I’ve only used UUID in Postgres database, so if you use MySQL I’ll be in debt.

# /db/migrations/0000000000_enable_pgcrypto_extension.rb
class EnablePgcryptoExtension < ActiveRecord::Migration[6.1]
  def change
    enable_extension 'pgcrypto'
  end
end

# /config/initializers/generators.rb
Rails.application.config.generators do |g|
  g.orm :active_record, primary_key_type: :uuid
end

# /db/migrations/000000_create_users.rb
class CreateUsers < ActiveRecord::Migration[6.1]
  def change
    create_table :users, id: :uuid do |t|
      t.string :name
    end
  end
end

Hash IDs: Balancing Security and Readability

Hash IDs represent a cryptographic approach to generating unique identifiers by transforming numerical values into hashed strings. This technique offers several advantages, including enhanced security, improved readability, and collision avoidance. By obscuring database sequences, Hash IDs mitigate the risk of enumeration attacks and unauthorized access. Platforms like YouTube leverage Hash IDs to create user-friendly URLs, enhancing usability and brand recognition. However, Hash IDs also pose challenges, such as non-sequentiality and dependency on hashing algorithms. Despite these considerations, Hash IDs remain a popular choice for applications prioritizing security and user experience.

Advantages

1. Security: Hash IDs obscure the underlying database sequence, enhancing privacy and deterring malicious activities such as data scraping and enumeration attacks. By transforming numerical IDs into hashed strings, sensitive information remains hidden from unauthorized access.
2. Readability: Hash IDs can be tailored to generate human-readable strings, enhancing user experience and URL aesthetics. Platforms like YouTube leverage Hash IDs to create user-friendly URLs, improving usability and brand recognition.
3. Collision Avoidance: Hash algorithms strive to minimize the likelihood of collisions, ensuring the uniqueness of generated IDs within practical constraints. While collisions can still occur, modern hash algorithms maintain a high level of collision resistance, reducing the risk of duplicate IDs.
4. Customization: Hash IDs offer flexibility in tailoring encoding schemes and incorporating application-specific logic. Platforms like YouTube can customize Hash IDs to incorporate additional metadata or encoding schemes, optimizing resource management and user experience.

Disadvantages

1. Non-Sequentiality: Hash IDs are non-sequential, which may complicate certain database operations like range queries or sorting. While platforms like YouTube prioritize security and user experience over sequentiality, developers must carefully consider the impact of non-sequential IDs on database performance and query optimization.
2. Dependency on Algorithms: The effectiveness of Hash IDs hinges on the cryptographic robustness of underlying hashing algorithms. Weak hash algorithms or improper configuration may compromise security and expose vulnerabilities to attacks like hash collisions or brute force decryption.
3. Limited Encoding Space: Depending on configuration, Hash IDs may have a finite encoding space, potentially leading to collisions in high-throughput environments. Balancing encoding space and collision resistance is essential to ensure the scalability and reliability of Hash IDs in large-scale deployments.

Potentialities

1. Enhanced Security: With proper configuration, Hash IDs can bolster data security and mitigate risks associated with exposing numerical IDs. By obscuring database sequences and deterring enumeration attacks, Hash IDs contribute to overall system security and integrity.
2. Improved User Experience: Hash IDs enable the creation of user-friendly, readable URLs, enhancing usability and brand recognition. Platforms like YouTube leverage Hash IDs to optimize user experience and facilitate content discovery through intuitive, descriptive URLs.
3. Scalability and Performance: Hash IDs promote efficient indexing and retrieval in high-throughput environments, ensuring optimal performance and scalability. By balancing collision resistance and encoding space, Hash IDs facilitate seamless resource management and query optimization in large-scale deployments.
4. Customization and Optimization: Hash IDs offer flexibility, enabling tailored encoding schemes and metadata incorporation. Platforms can optimize Hash IDs to meet specific application requirements, enhancing resource management, and user engagement.

YouTube’s Hash ID Implementation: A Case Study

YouTube, one of the world’s largest video-sharing platforms, utilizes Hash IDs extensively for various reasons:

1. Security: Hash IDs obscure the underlying database sequence, enhancing privacy and deterring malicious activities such as data scraping or enumeration attacks.
2. Readability: Hash IDs allow YouTube to generate user-friendly video URLs, enhancing usability and brand recognition.
3. Consistency: Hash IDs provide a consistent format for video identifiers, simplifying resource management and URL generation across the platform.
4. Scalability: With millions of videos uploaded daily, Hash IDs facilitate efficient indexing and retrieval, ensuring optimal performance and scalability.
5. Customization: YouTube can customize Hash IDs to incorporate additional metadata or encoding schemes, further optimizing resource management and user experience.

By leveraging Hash IDs, YouTube maintains a balance between security, scalability, and user experience, reinforcing its position as a leading video-sharing platform in the digital landscape.

How to do this

We have the perfect hashing algorithm for this work: Hashids. There are several different Gems that do the same work as the code above, but I have a philosophy that says that if a file solves the problem there is no need to add another external library resulting in more complexity and problems when updating. There is no need to have a gem and have to deal with the hassles of maintaining it. But the same way that I did for Gravatar, I opened hashid-rails gem and took what is important:

# /app/models/concerns/hashable.rb
# frozen_string_literal: true

# Hashids - Change the numeric identifications to hash identifiers
# Based on a simplification of 'hashid-rails gem' but avoiding yet another gem that could be a concern file.
module Hashable
  extend ActiveSupport::Concern

  def hashid
    self.class.encode_id(id)
  end

  def to_param
    hashid
  end

  # Methods for the Model Class
  module ClassMethods
    def encode_id(ids)
      if ids.is_a?(Array)
        ids.map { |id| hashid_encode(id) }
      else
        hashid_encode(ids)
      end
    end

    def decode_id(ids)
      if ids.is_a?(Array)
        ids.map { |id| hashid_decode(id) }
      else
        hashid_decode(ids).first
      end
    end

    def find(*ids)
      expects_array = ids.first.is_a?(Array)

      uniq_ids = ids.flatten.compact.uniq
      uniq_ids = uniq_ids.first unless expects_array || uniq_ids.size > 1

      if uniq_ids.is_a?(Array)
        uniq_ids.map do |id|
          id.is_a?(Integer) ? super(id) : super(decode_id(id))
        end
      else
        uniq_ids.is_a?(Integer) ? super(uniq_ids) : super(decode_id(uniq_ids))
      end
    end

    def find_by_hashid(hashid)
      find_by id: decode_id(hashid)
    end

    def find_by_hashid!(hashid)
      find(decode_id(hashid))
    end

    def hashid
      encode_id(id)
    end

    private

    def hashids
      Hashids.new(self.class.name + ENV.fetch('HASHID_TOKEN', ''), 8)
    end

    def hashid_encode(id)
      return nil if id.nil?

      hashids.encode(id)
    end

    def hashid_decode(id)
      hashids.decode(id)
    rescue Hashids::InputError
      id
    end
  end
end

Now we just have to add a line to the model that we want to use hashids and it’s all done:

class User < ApplicationRecord
  include Hashable
end

Slugs: Human readability, URL-friendly

Slugs represent a human-readable, URL-friendly string derived from a source text, typically used to represent titles, names, or other descriptive elements.

Advantages

1. Readability: Slugs create human-friendly URLs that are easy to read and understand, improving the overall user experience. Descriptive slugs provide users with valuable context about the content they are accessing.
2. SEO Optimization: By including relevant keywords and descriptive elements in the URL, slugs contribute to better search engine visibility and ranking. Search engines often use URLs as part of their ranking algorithms, making SEO-friendly slugs essential for driving organic traffic.
3. Brand Consistency: Consistently formatted slugs contribute to brand recognition and consistency across web pages. Users can easily identify content from the URL, reinforcing brand identity and credibility.
4. Compatibility: Slugs adhere to web standards and are compatible with various web browsers and platforms. They facilitate easy sharing and linking of content across different channels, including social media and email.

Disadvantages

1. Uniqueness: Ensuring the uniqueness of slugs across a large dataset can be challenging, especially in environments where multiple users can create content simultaneously. Conflicting slugs may lead to URL collisions and accessibility issues.
2. Character Limitations: URLs have character limitations, and slugs must adhere to these constraints to ensure compatibility and avoid truncation issues. Long titles or descriptive elements may require truncation or abbreviation, potentially affecting readability.
3. Text Processing Complexity: Generating slugs involves processing and sanitizing text inputs to remove special characters, whitespace, and other non-URL-friendly characters. This text processing complexity can introduce performance overhead and require careful handling of edge cases.
4. Internationalization: Supporting multilingual content poses challenges for slug generation, as different languages may have unique character sets and conventions. Ensuring consistent and SEO-friendly slugs across languages requires careful consideration and possibly language-specific handling.

Potentialities

1. Customization: Slugs offer flexibility in customization, allowing developers to incorporate branding elements, keywords, and relevant metadata into URLs. Customizable slugs enable tailored SEO strategies and branding initiatives.
2. SEO Enhancement: Optimizing slugs for SEO can significantly impact search engine visibility and ranking, driving organic traffic and user engagement. Strategic use of keywords and descriptive elements in slugs improves content discoverability and relevance.
3. User Engagement: User-friendly slugs enhance user engagement by providing clear and descriptive URLs that users can easily remember and share. Improved usability and readability contribute to positive user experiences and higher retention rates.
4. Localization: Tailoring slugs to different languages and regions facilitates localization efforts, ensuring that content remains accessible and relevant to diverse audiences. Localized slugs contribute to global brand reach and engagement.

How to do this

You could use a script similar to the one I provided above to override the find method and use the slug as the main parameter or simply change the call in the controller, which would be:

@user = User.find(params[:id])

To:

@user = User.find_by(slug: params[:id])

Conclusion: My Opinion

So which option should I use? As always the answer is…it depends.

Firstly, sequential ID is rarely a good option unless you want the sequential ID to be part of the functionality, for example you want to show the user that one ID is older than another. At a time when there were few messaging applications and ICQ dominated the world, having an ICQ number with less than 6 digits was a sign of status, that you were “old” on the platform.

As I said in the same session, UUID only makes sense if you want to manipulate decentralized database systems. Keep in mind that a UUID takes up a little more space than an integer, but not that much.

My preferred option is Hash ID, this solution works for 99% of cases. It does not take up extra space in the database, on the other hand it requires a little more encryption/decryption processing. Do I have a user model? Are they invoices? Are they work orders? Throws a Hash ID. Everything’s solved.

Finally, if I need the ID to be part of a URL and need to work SEO or have some meaning, the solution is slug. The slug will result in a significant increase in database space and even more creating an index just for it, but in terms of being something more user-friendly it has no equal. Is my user model for sharing with other people (like on Linkedin)? Am I creating IDs for blog posts? There’s nothing to think about, it’s Slug.

I hope this collection of information about the use of ID has been useful.

At its core, Gravatar assigns a unique avatar to each user’s email address. When users comment on blogs, participate in forums, or interact on various websites, their Gravatar image automatically appears alongside their contributions. This consistent visual representation fosters a sense of identity and community across different online platforms.

One of the key advantages of Gravatar is its convenience. Users can create or update their avatar once, and it will automatically propagate across all Gravatar-enabled sites, eliminating the need to upload a profile picture individually on each platform. This streamlined process saves time and ensures consistency in online branding.

Additionally, Gravatar offers users control over their privacy settings, allowing them to choose between public, private, or rated content for their avatars.

In summary, Gravatar simplifies online identity management, fosters community engagement, and provides users with a convenient and customizable way to represent themselves across the web.

Furthermore, there is no need to create a feature in your application to save your user’s photo, we don’t need to have storage space for these photos, the user doesn’t need to go through the trouble of sending their photo to each application they want to use, and if he doesn’t want to be identified, we can still leave a drawing of a funny robot or alien that changes and maintains the same pattern by email.

How to do it

There are several Gems that can do the task. But this is a very easy functionality to have and a simple file added to the /app/models/concerns folder solves the problem. There is no need to have a gem and have to deal with the hassles of maintaining it. Especially because many of the gravatar gems I’ve seen are already very out of date.

So just add the file below:

# frozen_string_literal: true

# /app/models/concerns/gravatable.rb

# From:
# https://github.com/chrislloyd/gravtastic/blob/master/lib/gravtastic.rb
# https://chrislloyd.github.io/gravtastic/

require 'digest/md5'

# Module to generate Gravatar URL
module Gravatable
  extend ActiveSupport::Concern

  # The raw MD5 hash of the users' email. Gravatar is particularly tricky as
  # it downcases all emails. This is really the guts of the module,
  # everything else is just convenience.
  def gravatar_id
    Digest::MD5.hexdigest(send(self.class.gravatar_source).to_s.downcase)
  end

  # Constructs the full Gravatar url.
  def gravatar_url(options = {})
    options = {
      rating: 'PG',
      secure: true,
      filetype: :png,
      default: :robohash, # options: 404, mp (mystery person), identicon, monsterid, wavatar, retro, robohash, blank
      size: 200
    }.merge(options)
    gravatar_hostname(options.delete(:secure)) +
      gravatar_filename(options.delete(:filetype)) +
      "?#{url_params_from_hash(self.class.process_options(options))}"
  end

  # private

  # Creates a params hash like "?foo=bar" from a hash like {'foo' => 'bar'}.
  # The values are sorted so it produces deterministic output (and can
  # therefore be tested easily).
  def url_params_from_hash(hash)
    hash.map do |key, val|
      [self.class.gravatar_abbreviations[key.to_sym] || key.to_s, val.to_s].join('=')
    end.sort.join('&')
  end

  # Returns either Gravatar's secure hostname or not.
  def gravatar_hostname(secure)
    "http#{secure ? 's://secure.' : '://'}gravatar.com/avatar/"
  end

  # Munges the ID and the filetype into one. Like "abc123.png"
  def gravatar_filename(filetype)
    "#{gravatar_id}.#{filetype}"
  end

  # Methods for the Model Class
  module ClassMethods
    attr_accessor :gravatar_source

    def gravatar_field(source = :emailx)
      @gravatar_source = source
    end

    # Some options need to be processed before becoming URL params
    def process_options(options)
      processed_options = {}
      options.each do |key, val|
        case key
        when :forcedefault
          processed_options[key] = 'y' if val
        else
          processed_options[key] = val
        end
      end
      processed_options
    end

    def gravatar_abbreviations
      { size: 's',
        default: 'd',
        rating: 'r',
        forcedefault: 'f' }
    end
  end
end

In any model that has the email field, just add the Gravatable as below:

class User
  include Gravatable

  gravatar_field :email
end

User.last.gravatar_url({ size: 40 })

As you can see in the code, it is not mine originally. I created a version from the Gravtastic gem that has not been updated since 2016.

Today I had a need that I keep having and I always used another way to solve it. I had never used this bank before, but they came to me asking to change the contract number to, say, ‘666/2014’ where before it was ‘333/2012’. How to make? Normally I dump the database and search the text in text mode (using an editor or the grep command). But talking to my friend DBA (thanks Adolfho Lopes!) we decided to do it another way.

Below is the result, but be careful: Use in moderation! These functions are to be used in times of need and in a hurry. Never in production. Don’t do that, otherwise the bank would collapse! :)

CREATE TYPE table_master_search_table AS (
    tname varchar,
    cname varchar,
    found varchar
);

CREATE OR REPLACE FUNCTION master_search_table(p_search_string varchar, p_tablecatalog varchar, p_tableschema varchar, p_tablename varchar)
RETURNS SETOF table_master_search_table AS
$$
DECLARE r record;
   r2 table_master_search_table%rowtype;
   t1 table_master_search_table;
   command varchar;
BEGIN
  FOR r IN SELECT table_name, column_name, data_type from information_schema.columns
	where table_catalog = p_tablecatalog and table_schema = p_tableschema and table_name = p_tablename LOOP
	command := 'SELECT '''|| r.table_name || ''' tname, '''|| r.column_name || ''' cname, ' || r.column_name|| ' found FROM ' || r.table_name || ' WHERE cast(' || r.column_name || ' as varchar) like ''%' || p_search_string || '%''';
	raise notice '%',command;
    FOR r2 IN EXECUTE command LOOP
     return NEXT r2;
    END LOOP;

  END LOOP;
END
$$ LANGUAGE plpgsql;

CREATE TYPE table_master_search AS (tname varchar, quant integer);
CREATE OR REPLACE FUNCTION master_search(p_search_string varchar, p_tablecatalog varchar, p_tableschema varchar)
RETURNS SETOF table_master_search AS
$$
declare
  num int:=1;
  col record;
  tab record;
  comando varchar;
  r table_master_search%rowtype;
BEGIN
  FOR tab in select table_name from information_schema.tables where table_schema=p_tableschema and table_type = 'BASE TABLE' LOOP
   comando = 'select '''|| tab.table_name || ''' tname, count(1) quant from '||tab.table_name||' where ';
   FOR col in select count(1) over (partition by table_name) numcols, row_number() over (partition by table_name) seq, * from information_schema.columns
	where table_schema = p_tableschema and table_name = tab.table_name LOOP
       comando :=  comando || 'cast(' || col.column_name ||' as varchar) like ''%' || p_search_string ||'%''';
       IF col.seq <> col.numcols then
         comando :=  comando || ' or ';
       END IF;
   END LOOP;
   RAISE notice '%',comando;
   EXECUTE comando into r;
   IF r.quant > 0 then
     RETURN next r;
   END IF;
  END LOOP;
END
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION master_search_full(p_search_string varchar, p_tablecatalog varchar, p_tableschema varchar)
RETURNS SETOF table_master_search_table AS
$$
declare
  num int:=1;
  col record;
  tab record;
  comando varchar;
  r table_master_search_table%rowtype;
BEGIN
  FOR tab IN SELECT * FROM master_search(p_search_string, p_tablecatalog, p_tableschema) LOOP
    FOR r IN SELECT * from master_search_table(p_search_string, p_tablecatalog, p_tableschema, tab.tname) LOOP
     RETURN next r;
    END LOOP;
  END LOOP;
END
$$ LANGUAGE plpgsql;

select * from master_search_table('string', 'catalogo', 'schema', 'usuarios');
select * from master_search('string', 'catalogo', 'schema');
select * from master_search_full('string', 'catalogo', 'schema');

The Internet basically self-regulates. There are some organizations that try to establish some rules, but they are very few and have almost negligible power. Who determines most of the network rules are the companies themselves that provide access to anyone who wants to use the Internet (that is, almost everyone). It’s a libertarian’s paradise. The few organizations managed in part by governments are the ones that manage domain names. You can buy a domain name of any type just by looking for the organization responsible for that nationality. In other words, if I want to buy a .com.br, I need to go to registro.br, which is the Brazilian Internet Steering Committee. By paying only R$ 30.00, you become the happy owner of yourdomain.com.br. So far so good. Or you can use a company that registers in various country organizations, like name.com and godaddy.com.

Just like physical property, domain names have a significant social function on the internet. They are like addresses on a busy street, indicating the location of services, companies, and information. However, the proliferation of registered but unused domains presents a dilemma similar to real estate speculation. There are many cases where I am creating a service, have the perfect name to call my clientele, but the domain is already registered. I accept that someone else had the same idea as me for a domain name. As they say, ideas are in the air, and I don’t own them. However, it makes me very angry when the domain I thought of with so much care and has already been registered is a page like this:

This happened to me when I tried to create an e-commerce about regional articles with my group in a Startup Weekend (promoted by Google). We had the whole concept of longing for the homeland and we thought of the name “banzo” that refers to that. However, besides the name being registered, it was empty. A virtual void waiting for speculation. Yes, because besides the page only having advertisements, it has a link to buy this domain for the tidy sum of $2,000.00 (a .com domain normally costs around $10.00).

In many cases, domains are acquired solely for future resale, without contributing to the development or utility of the web. This practice, known as cybersquatting, creates a scenario where valuable domain names are registered and kept idle, waiting for profit opportunities. It’s a huge market of thousands of domains available for auctions at very high prices. The phenomenon of “domain parking,” where empty pages are maintained only with ads or related links, reflects a lack of social responsibility in the use of these resources. Just waiting for someone to pay a fortune or even not, just because the owner wants to have this domain and it’s his and no one else’s. Screw you if you have a disadvantaged idea and could make some money. I don’t care if my domain has no function other than me saying it’s mine.

Just as physical property must fulfill a social function, be it residential, commercial, or public, domain names should also actively contribute to the online community. In Brazil, the 1988 Constitution established the principle of the social function of property, aiming to prevent speculation and promote the effective use of resources. Contrary to what some say, the social function does not mean that it should be available to society as if your property were not yours. It means that it should be there performing some function.

In Brazilian cities, there are thousands of speculators who buy land at very low prices and leave them there without any function, just waiting for the city to grow around them and the value of the land to skyrocket. This is one of the ways to promote real estate speculation. This practice is extremely harmful to the city as it forces the government to expand its water, electricity, and sewage services (the latter is very expensive) to increasingly distant areas without real necessity because in between are large urban voids with no function at all.

The City Statute (law of 2001) defined some tools to avoid this speculative practice and to compel property owners to fulfill the social function of property. The tools range from progressive property tax (where the tax increases annually as the owner does not give a function to it) to expropriation. Are these tools being used in the city? I don’t see it.

Analogously, it would be beneficial for the organizations responsible for managing domain names to introduce similar policies. A system of “virtual progressive property tax” could encourage the active use of domains, penalizing owners who keep them idle. This could help mitigate the problem of registered but unused domains, ensuring that these resources are allocated more efficiently and for the benefit of the online community as a whole.

How about creating the PVPT (Progressive Virtual Property Tax)?

É a primeira vez que estou pegando um artigo de blog e traduzindo para português. Fiz isso porque considero as razões elencadas muito pertinentes e podem servir como base de debates. Aqui está apenas a versão traduzida, se quiser ler o original, clique aqui.

Com a palavra, o sr. Atwood do CodingHorror:

Por que Ruby?

Tenho sido desenvolvedor Microsoft por algumas décadas até hoje. Eu dei meus primeiros passos em vários sabores do Microsoft Basic para PC, e recebi meu primeiro pagamento programando em Microsoft FoxPro, Microsoft Access, e Microsoft Visual Basic.Eu vi o futuro da programação, meus amigos, e ele é terriveis aplicações de CRUD rodando em maquinas Wintel!

É claro, construimos o Stack Overflow em Microsoft.NET. Este é o grande motivo de ele ainda ser tão rápido quanto é. Então uma das perguntas mais frequentemente feitas depois que anunciamos o Discourse foi:

Por que vocês não desenvolveram o Discourse em .NET também?

Deixemos claro uma coisa: Eu amo .NET. Uma das grandes emoções da minha carreira profissional foi ter a oportunidade de colocar um adesivo do Coding Horror nas mãos de Anders Hejlsberg. Perdoe meu fanboy interior por um momento, mas caramba, eu ainda me arrepio. Devem ter talvez uns cinquenta projetistas de linguagem de classes de computador pelo mundo. Anders é apenas um deles que criou o Turbo Pascal e o Delphi. É graças à experiência de Anders que o .NET começou com uma linguagem tão bem projetada – literalmente o que o Java deveria ter sido em todo o nível concebível – e tem evoluído extraordinariamente de modo continuo em meios práticos pelos últimos 10 anos, aproveitando os pontos fortes de outras linguagens dinamicamente influentes.

Dito tudo isso, é verdade que eu intencionalmente escolhi não usar .NET para o meu próximo projeto. Então você pode esperar encontrar alguém bravo arengando aqui sobre o quão mais feliz estou deixando as amarras opressoras dos meus senhores Microsoft para trás. Livre afinal, livre, pelo menos, graças a Deus todo-poderoso eu sou livre enfim!

Sinto muito. Já escrevi este post cinco anos atrás.

Como qualquer programador pragmático, eu escolhi a ferramenta apropriada para o trabalho em mãos. E por mais que eu ame o .NET, ele seria uma escolha extraordinariamente pobre para um projeto 100% software livre como o Discourse. Por que? Três razões em especial:

1 O licenciamento. Meu Deus, o licenciamento. Nem é tanto pelo dinheiro, como é infernal o alucinante nível de complexidade em ter certeza de que todo o seu software é licenciado apropriadamente: determinando em qual nível e edição você está licenciado, quem é licenciado para usar o que, qual servidores são licenciados… Han? Que? Desculpa, passei lá por um minuto, quando fui atacado por doninhas raivosas do licenciamento.

Eu não estou inclinado a fazer grandes declarações sobre o futuro do software, mas se há algo que vai mata o software comercial, deixe-me dizer-lhe, não será um software de código aberto.

2 O atrito. Se você quer construir um software open source verdadeiramente viável, você precisa de pessoas para contribuir com o seu projeto, de modo que se trate de uma coisa vivente, respirando e crescendo. E a não ser que você possa baixar todo o software que precisa para hackear o seu projeto de forma livre por toda a Internet, sem amarras, haverá atrito demais.

Se Stack Overflow me ensinou algo, é que hoje nós vivemos num mundo onde o próximo engenheiro de software brilhante pode vir de qualquer lugar do planeta. Estou falando de lugares que esse programador americano e feio nunca escutou falar, onde se fala línguas doidas e sem sentido que eu não entendo. Mas entenda. Afaste-se um pouco enquanto eu explodo seus cérebros, gente: esses programadores brilhantes ainda desenvolvem usando as mesmas palavras-chave que nós! Eu sei, louco né?

Levantar e rodar em um ambiente Microsoft é simplesmente muito difícil para um desenvolvedor, digamos, na Argentina, ou no Nepal, ou na Bulgária. Cadeias de sistemas Operacionais, linguagens e ferramentas livres são os grandes equalizadores, a base para a nova grande geração de programadores por todo o mundo onde estão em vias de nos ajudar a mudar o mundo.

3 O Ecosistema. Quando eu estava no Stack Exchange, nós brigamos para fazer o máximo que podiamos para que a nossa infraestrutura fosse open source. Foi algo que deixamos explícito nas nossas orientações de compensação, essa ideia de que nós seriamos (parcialmente) julgados pelo quanto poderíamos fazer em público, e tentar deixar o quanto de artefatos públicos e úteis do nosso trabalho quanto podíamos. Mas por que todo o Stack Exchange não foi criado sob Creative Commons contributions desde o primeiro dia?

Você pode certamente desenvolver software código aberto em .Net. E muitos o fazem. Mas isto nunca parece natural. Isto nunca parece correto. Ninguém aceita uma correção para uma biblioteca de classe do core do .Net, não importa o quanto você tente. parece que você está nadando contra a corrente, em um mundo de pequenas e grandes empresas usando .Net onde elas não estão de fato interessadas em compartilhar o códigos com o mundo – provavelmente porque eles sabem que seriam ruim se o fizessem de qualquer forma. É que não faz parte da cultura do Microsoft .Net fazer coisas open source, especialmente coisas ruins. Se você tem medo de que as coisas que você compartilha sejam ruins, este medo vai te tornar incapaz de realmente e profundamente retribuir. O aspecto mais, digamos delicioso… das comunidades de código aberto é como eles não têm medo de deixar “tudo para fora”, por assim dizer.

Então como resultado, para qualquer tarefa em .Net você deve ter – se tiver sorte – de escolher entre talvez duas bibliotecas talvez decentes. Por outro lado, em qualquer linguagem open source popular, você terá facilmente uma dúzia de alternativas para a mesma função. Sim, talvez seis delas quebrem, seja obsoletas, não funcionem, ou sejam absolutamente loucas. Mas ei, mesmo levando em conta algumas deteriorações naturais de fonte aberta, você ainda está à frente por um fator de três! Você que sai ganhando!

Eu escrevi há cinco anos atrás:

“Eu sou pragmático. No momento, eu escolho viver no universo Microsoft. Mas isso não significa que sou ignorante de como os outros vivem. Sempre há mais de um jeito de fazer, e só porque eu escolhi uma em particular não quer dizer que seja a certa – nem mesmo uma maneira particularmente boa. Escolher ser provincial e insular é um caminho infalível para a ignorância. aprenda como os outros vivem. Tente conhecer alguns desenvolvedores que não vivem exatamente no mesmo mundo que você. Procure as ferramentas que estão usando, e porque. Se depois de molhar o seu pé nos dois lados da cerca, você decidir que o outro lado está vivendo melhor e deseja se juntar a eles, então te desejo um amoroso adeus.”

Eu não vivo mais no universo Microsoft. Certo, errado, bom, mau, é assim que ele saiu para o projeto que queríamos construir.

Contudo, eu estaria mentindo se não falasse que eu realmente acredito que o tipo de projeto que estamos construindo no Discourse representa sim o futuro do software. Se você olhar de soslaio um pouco, eu acho que você pode ver um futuro não muito distante onde o .Net é um nicho especializado fora do mainstream.

Mas por que Ruby? Bem, a menor resposta e não muito glamorosa é a de que eu reduzi a lista a Python ou Ruby, e meu co-fundador original Robin Ward vem construindo grandes aplicações em Rails desde 2006. Então isso me conquistou.

Eu sempre fui um pouco intrigado com o Ruby, principalmente por causa do absolutamente transbordante louvor que Steve Yegge fez com a linguagem muito tempo atrás em 2006. Eu nunca esqueci disso.

“Na maior parte, Ruby pegou o processamento de string e integração com o Unix do Perl, o que significa que a sintaxe é idêntica, e assim por ali mesmo, antes de qualquer coisa acontecer, você já tem o melhor de Perl. E isso é um grande começo, especialmente se você não pega o resto do Perl.

Mas então Matz pegou o melhor de processamento de listas do Lisp, o melhor de Orientação a Objetos do Smalltalk e outras linguagens, e o melhor de iterators do CLU, e basicamente o melhor de tudo de todos.

E ele de alguma forma fez com que tudo funcionasse junto tão bem que você nem percebe que é tudo isso. Eu aprendi Ruby mais rápido do que qualquer outra linguagem, de umas 30 ou 40 no total: levou uns 3 dias para que eu me sentisse muito mais confortável usando Ruby, do que em Perl, depois de oito anos de codificação em Perl. Ele é tão consistente que você começa a ser capaz de adivinhar como as coisas vão funcionar, e na maioria das vezes você está certo. É lindo. E divertido. E prático.”

Steve é um desses programadores poliglotas que eu respeito tanto que eu basicamente só tomo seja qual for a sua opinião, desde que não se trate de algo maluco como o controle de armas ou feminismo ou T’Pau, e aceito como fato.

Peço desculpas, Steve. Sinto muito que me levou 7 anos para dar a volta a Ruby. Mas talvez era melhor esperar um tempo de qualquer maneira:

• Ruby tem uma performance decente, mas você realmente precisa jogar uma maquina rápida para ele para ter um bom desempenho. Sim, eu sei, linguagens interpretadas são o que são, e cache, banco de dados, rede, blá blá blá. Ainda assim, obtivemos as maquinas mais rápidas que você pode comprar para os servidores Discourse, 4.0 Ghz Ivy Bridge Xeons, e a performance é apenas … boa no hardware mais rápido de hoje. Não muito bom. Bom.

Sim, eu vou admitir que estou completamente mimado pela performance do JIT compilado do .Net. É o que eu estou acostumado. Eu faço às vezes definhar para os maus velhos tempos de. NET quando poderíamos construir páginas que servem em bem menos de 50 milissegundos sem pensar muito. Linguagens interpretadas não vão ser capazes de alcançar esses níveis de desempenho. Mas eu só posso imaginar como o desempenho bruto Ruby tinha que estar de volta na idade das trevas de 2006, quando CPUs e servidores eram cinco vezes mais lento do que são hoje! Estou muito feliz que eu estou atacando de Ruby agora, com o forte vento de muitos anos sólidos da lei de Moore em nossas costas.

• Ruby está amadurecendo muito bem na versão 2.0 da linguagem, o que não aconteceu não mais que um mês depois do Discourse foi anunciado. Então, sim, a desvantagem é que Ruby é lento. Mas o lado positivo é que há um monte de Gems de baixa performance na Rubyland. No Discourse nós temos uma melhoria de desempenho de 20% apenas atualizando para o Ruby 2.0, e nós quase dobramos o nosso desempenho, aumentando o limite de garbage collector padrão do Ruby. De uma perspectiva de desempenho futuro, Ruby é nada mas vantagem.

• Ruby não é mais cool. Sim, você me escutou. Não é mais legal escrever código Ruby. Todas as pessoas legais se mudaram para Scala e Node.js anos atrás. Nosso projeto não é legal, é só um monte do código Ruby velho e chato. Pessoalmente, estou muito feliz que o Ruby agora é maduro o suficiente para que a comunidade não precise mais se preocupar com a pretensão de ser o garoto mais legal do bloco. Isto significa que o resto de nós que gosta apenas de deixar as coisas prontas (Get Shit Done) pode arregaçar as mangas e se concentrar na missão de construir coisas com os nossos pares, em vez de correr freneticamente tentando desvendar a próxima coisa brilhante.

E é claro que a comunida Ruby é e sempre foi, incrível. Nós nunca queremos para grandes gemas de código aberto e grandes contribuidores de código aberto. Agora é um momento fantástico para começar com o Ruby, na minha opinião, seja qual for o seu background.

(No entanto, é também importante ressaltar que o Discourse é, se alguma coisa, ainda mais um projeto JavaScript do que um projeto Ruby on Rails. Você não acredita em mim? Basta ir ao try.discourse.org e ver o código fonte. Um fórum de Discourse não é tanto de um website, mas uma aplicação bem desenvolvida em JavaScript que acontece de ser executado em seu navegador.)

Mesmo que sendo feito de boa vontade e para os melhores interesses do projeto, ainda é um pouco assustador mudar totalmente sua espécie de programação da noite para o dia depois de duas décadas. Eu sempre acreditei que os grandes programadores aprender a amar mais de uma linguagem e ambiente de programação – e espero que o projeto Discourse seja uma oportunidade para que todos possam aprender e crescer, não só comigo. Então vai e faz um fork no GitHub já!

So let’s go. The first thing to do is download all the data from the IBGE FTP at ftp://ftp.ibge.gov.br/Censos/Censo_Demografico_2010/Resultados_do_Universo/Agregados_por_Setores_Censitarios/. Prepare time and bandwidth as there are several files and quite large (28 files totaling more than 2.2Gb).

But the problem is not with the download. First, IBGE makes the files available in two formats: XLS and CSV. The problem is that their conversion from XLS to CSV did not come out correctly. Some CSV came with the sector code column in scientific notation format, and they must have gotten confused in the Espirito Santo file as they did not include one of the CSV and replaced it with an XLS… In other words, we cannot count on the saved CSV files by IBGE. Another error that I found later when entering the data into the tables was that the files are not standardized!!! For example, the surrounding files for the states of Ceará, Distrito Federal, Minas Gerais, Pernambuco and Rio Grande do Sul have fewer columns than the others. We will return to this below.

Another issue to think about is the dictionary of variables. Each state has 26 tables. And the dictionary for each table is in a PDF file inside each ZIP called INFORMATION BASE BY CENSUS SECTOR 2010 Census – Universo.pdf. An uninteresting format as it is very difficult to obtain the data in an automated way. The solution I found was to convert the PDF to DOC using this website. And then I had the legwork of converting each one into an XLS table. I made the file available for anyone who doesn’t want to do the work I did.

Returning to the data again. Those who use Linux have an advantage as it has several commands that make it possible to perform a batch conversion. Below is a shell script to run and transform the ZIPs you downloaded from the website into a single file for each of the 26 tables. Before running this script it is important that some programs are installed. To do this, just run:

sudo apt-get install unoconv libreoffice unzip

And the script:

#!/bin/sh

mkdir xls
for i in $(ls *.zip)
do
  unzip -j $i -x *.csv *.pdf -d xls
done
cd xls
unoconv -i 59,34,UTF-8 -f csv *
cd ..

for i in $(ls ./xls/*.csv | grep -v Basico)
do
  lc=`echo $i | tr '[A-Z]' '[a-z]'`
  sed '1d' $i | sed 's/,/./g' | sed 's/X//g' > $lc.csv
done

for i in $(ls ./xls/*.csv | grep Basico)
do
  lc=`echo $i | tr '[A-Z]' '[a-z]'`
  sed '1d' $i | sed 's/,/./g' > $lc.csv
done

cat ./xls/basico*.csv.csv > Basico.csv
cat ./xls/domicilio01*.csv.csv > Domicilio01.csv
cat ./xls/domicilio02*.csv.csv > Domicilio02.csv
cat ./xls/domiciliorenda*.csv.csv > DomicilioRenda.csv
cat ./xls/entorno01*.csv.csv > Entorno_01.csv
cat ./xls/entorno02*.csv.csv > Entorno_02.csv
cat ./xls/entorno03*.csv.csv > Entorno_03.csv
cat ./xls/entorno04*.csv.csv > Entorno_04.csv
cat ./xls/entorno05*.csv.csv > Entorno_05.csv
cat ./xls/pessoa01*.csv.csv > Pessoa01.csv
cat ./xls/pessoa02*.csv.csv > Pessoa02.csv
cat ./xls/pessoa03*.csv.csv > Pessoa03.csv
cat ./xls/pessoa04*.csv.csv > Pessoa04.csv
cat ./xls/pessoa05*.csv.csv > Pessoa05.csv
cat ./xls/pessoa06*.csv.csv > Pessoa06.csv
cat ./xls/pessoa07*.csv.csv > Pessoa07.csv
cat ./xls/pessoa08*.csv.csv > Pessoa08.csv
cat ./xls/pessoa09*.csv.csv > Pessoa09.csv
cat ./xls/pessoa10*.csv.csv > Pessoa10.csv
cat ./xls/pessoa11*.csv.csv > Pessoa11.csv
cat ./xls/pessoa12*.csv.csv > Pessoa12.csv
cat ./xls/pessoa13*.csv.csv > Pessoa13.csv
cat ./xls/pessoarenda*.csv.csv > PessoaRenda.csv
cat ./xls/responsavel01*.csv.csv > Responsavel01.csv
cat ./xls/responsavel02*.csv.csv > Responsavel02.csv
cat ./xls/responsavelrenda*.csv.csv > ResponsavelRenda.csv

Just put all the ZIP files in a folder together with this script and run. Line 02 creates a folder. Then, in lines 03 to 06, all XLS in that folder are unzipped. Line 08 converts all XLS files to CSV using delimiter ; (whose code is 59) and text delimiter ” (whose code is 34) and still using UTF-8 encoding.

Finally, the subsequent lines use the sed command twice, the first to remove the first line from all files and then to replace the comma with a period in the data and join everything in a single file.

Ready. The files are ready to play in the bank. Then I created a small PHP script that converts the XLS with the XLS table that I mentioned earlier that will generate SQL to execute in PostgreSQL:

passthru("unoconv -i 59,34,UTF-8 -f csv DadosCenso2010.xls");

$dic = file('DadosCenso2010.csv');
$sql_bd = Array();
$sql_banco = '';
$sql_populate = '';
$tit = false;
$path = '/home/artz/censo/dados/';

$sql_dic = << CREATE TABLE dicionario
(
  cod serial,
  banco character varying,
  variavel character varying,
  descricao character varying
);

SQL_DIC;
$i = 0;
foreach($dic as $v) {
  $v = explode(';', $v);

  if($tit == true) {
    if($v[0] != '') {
      if(count($sql_bd) > 0) {
        $sql_banco .= "CREATE TABLE " . $titulo . "_2010_SC (\n"
          . implode(",\n", $sql_bd)
          . ");\n\n";
        $sql_populate .= "COPY " . $titulo . "_2010_SC FROM '" . $path . $titulo . ".csv' DELIMITERS ';' CSV;\n";
        $sql_bd = Array();
        echo "Creating $titulo...\n";
      }
      $titulo = str_replace(' ', '_', tiracento($v[0]));
      $desc = $v[1];
      $tit = false;
    }
  } else {
    if($v[0] == '') {
      $tit = true;
    } else {
      $v[0] = str_replace(' ', '_', tiracento($v[0]));
      $sql_dic .= "INSERT INTO dicionario (banco, variavel, descricao) VALUES ('" . $titulo . "_2010_SC', '" .$v[0] . "', '" . $v[1] . "');\n";
      $sql_bd[] = " " . $v[0] . ($v[2]==1 ? " character varying" : " numeric");
      $tit = false;
    }
  }
}

if(count($sql_bd) > 0) {
  $sql_banco .= "CREATE TABLE " . $titulo . "_2010_SC (\n"
  . implode(",\n", $sql_bd)
  . ");\n\n";
  $sql_populate .= "COPY " . $titulo . "_2010_SC FROM '" . $path . $titulo . ".csv' DELIMITERS ';' CSV;\n";
  $sql_bd = Array();
  echo "Creating $titulo...\n";
}

function tiracento($texto){
  $trocarIsso = array('à','á','â','ã','ä','å','ç','è','é','ê','ë','ì','í','î','ï','ñ','ò','ó','ô','õ','ö','ù','ü','ú','ÿ','À','Á','Â','Ã','Ä','Å','Ç','È','É','Ê','Ë','Ì','Í','Î','Ï','Ñ','Ò','Ó','Ô','Õ','Ö','O','Ù','Ü','Ú','Ÿ',);
  $porIsso = array('a','a','a','a','a','a','c','e','e','e','e','i','i','i','i','n','o','o','o','o','o','u','u','u','y','A','A','A','A','A','A','C','E','E','E','E','I','I','I','I','N','O','O','O','O','O','0','U','U','U','Y',);
  $titletext = str_replace($trocarIsso, $porIsso, $texto);
  return $titletext;
}

$f = fopen('out.sql', 'w');
fwrite($f, $sql_dic . "\n\n" . $sql_banco . "\n\n" . $sql_populate);
?>

Be assured that the procedure is not that simple. But it’s at least a little help.

I took advantage of a joystick module I already had and adapted the mouse control.

So here’s the recipe:

Ingredients

• Teensy 2.0
• Joystick KY-023 Module
• some wire
• USB adapter

The Code

int joyPin1 = PIN_F0;
int joyPin2 = PIN_F1;
int v1 = 0;
int v2 = 0;
int v1Padrao = 0;
int v2Padrao = 0;
int passo = 20;

void setup() {
  Serial.begin(9600);
  v1Padrao = analogRead(joyPin1);
  delay(100);
  v2Padrao = analogRead(joyPin2);
}

int change(int v, int unchange, int max_state) {
  if(v > unchange) {
    return int(passo * ( v – unchange ) / (max_state – unchange));
  } else if (v < unchange) {
    return int( (v / unchange * passo) – passo );
  }
  return 0;
}

void loop() {
  v1 = analogRead(joyPin1);
  delay(100);
  v2 = analogRead(joyPin2);
  Serial.println(“—-“);
  Serial.print(v1);
  Serial.print(” – “);
  Serial.println(change(v1, v1Padrao, 1023));
  Serial.print(v2);
  Serial.print(” – “);
  Serial.println(change(v2, v2Padrao, 997) );
  Mouse.move( change(v1, 506, 1023) , change(v2, 512, 997) );
  delay(100);
}

The Schematics

Some explanations

The Joystick is nothing more than two potentiometers and a button (in case you press the joystick down). The VRx and VRy terminals are connected to the Teensy’s analog ports while the SW terminal, which is the button, is connected to a digital port (although it is not being used). The analog ports range from Zero to 1023. However, after some tests I discovered that on one axis the values range from zero to 1023, stopping at 506 when it is centered, and the other axis goes from zero to 997, stopping at 512. Certainly other pieces will have different limits. The change function adapts the value returned by the potentiometers to the most interesting number for the mouse function, which should range from -127 to 127. Problems

I tried to make the button that comes with it work as a mouse click, however I don’t know why sometimes the value is zero and other times it is 1 without even moving the joystick. Another issue is that it doesn’t always move in the right direction. I didn’t understand the reason. If anyone knows, please explain to me.

Here is the result

Even though Firefox already has a debugger built in and they all work with the same message warning command (console.log and others), I can’t seem to let go of Firebug. This also has its downside because when I need to test my application in another browser I get lost. Even Internet Explorer has already incorporated its debugger tool, and there is no way to include a Firebug Lite like Chrome (or is there?). So I have to use it anyway. Despite having very interesting functions, such as the possibility of testing the page on previous versions, overall I find it very weak…

But back to the subject: OpenLayers. I’m using several Basemaps (which are the maps that are underneath the layers you’re going to work on. It’s only allowed to show one basemap at a time, after all, they take up all the space and it wouldn’t even be possible to see more than one at a time, unless unless we used transparency (I will test this possibility later)…

But here’s the problem. I’m using Google Maps, Google Satellite, Google Hybrid, Google Terrain and OpenStreetMap as a base, the latter being the default layer. In Firefox, they worked fine. When I tested the application in other browsers, they opened in OpenStreetMap (by default) and it also seemed to work.

One fine day (later it wasn’t so beautiful) I’m going to do a demonstration of the application and the machine I was going to show didn’t have Firefox, just IE 9 (at least it was 9!) and the other base layers (those from Google ) simply did not appear. After the embarrassment I experienced in that demonstration, I went looking for the reason for this and couldn’t find anything on the subject. I updated the OpenLayers version, at the time, to 2.11 and nothing. I looked inside the OpenLayers.js, inside the stylesheets and nothing… I gave up after searching so much for the reason.

When I was at the end of the development of this project, about to go into production, I committed myself once again to solving this bug. Version 2.12 of OpenLayers had just come out of the oven and, thinking that this bug would be resolved, I updated once again. And once again, nothing.

Another good time of research when I found the solution on a Drupal forum: to fix the problem I just needed to replace the blank.gif file that was defective and prevented Google images from being displayed.

Just replacing this file in the OpenLayers images made Google Maps appear in IE like magic.

But there are some questions:

• What was in the previous blank.gif that prevented it from being viewed?

• Why did this problem only occur in IE?

• How could I waste so much time on something so foolish?