Introduction

First, Brexit, Then electing El-Sisi as president of Egypt, And now the election of Donald Trump as president of the United States. What happened? Can we be sure any longer that democracy works? Is it really the reliable bulwark against political madness that we always supposed?

The reason I am beginning to question democracy is that it is producing results I profoundly dislike. After all, democracy has not been changed much the past few decades. Democracy is obviously not the fastest route to modern society. High development is associated with democracy in the long run, but dictatorship in the short run. So we go with dictatorship? of course not, dictatorship can make progress or damage in shorter period of time so we can say it’s risky to be used.

So what? How about weighted-democracy with stock options like civil merits plus a benevolent tyrant helping people make the best decisions? Not bad at all. What about the economy? What about education? All shall be answered today in my article.

Implementation

To design my own Country, I’ll be using the programming language I love the most, Ruby. You can’t expect the code to be used in real-life, however I like to use the code as it make it easier for the readers to memorise ideas, and mmm it’s definitely more fun this way :P

Note that the code sections are not required and you can skip it if you are not from programming backgrounds. After all this article is not intended for programmers only.

I’ll start by naming my imaginary country, I’ll call it “AweLand”, It’s gonna be the best country no doubt. When all your problems solved in a O(log N) complexity.

Now, at this point, you may be wondering if I totally lost it. The answer is not yet. What I want to do today is debate how the world ought to be governed. I’ll give you my personal Ruby vision of what a proper country should look like :)

Few notes before I start digging deeper. I’ll be using Ruby, I’ll be using BDD with RSpec too. I’ll use composition and delegation rather than inheritance. I’ll try to follow SRP(Single Responsibility Princile), KISS (Keep It Simple Stupid), DRY (Don’t Repeat Yourself) and SUC (Shut Up and Code) nah I just made up this one :)

My country will be composed of Government, Civil liberties, Health-care, Education , Economy and Religion.

I’ll use Bundler to organise my files so I’ll create a new gem/library:

bundle gem country
   create  country/Gemfile
   create  country/Rakefile
   create  country/LICENSE.txt
   create  country/README.md
   create  country/.gitignore
   create  country/country.gemspec
   create  country/lib/country.rb
   create  country/lib/country/version.rb

The files structure would look like:

country
├── Gemfile
├── LICENSE.txt
├── README.md
├── Rakefile
├── country.gemspec
└── lib
    ├── country
    │   └── version.rb
    └── country.rb

Now let’s write few rspecs to support our case.

# country_spec.rb

describe Country do
    let(:country) { Country.new }

    it 'called AweLand.' do
      expect(country.name).to eq("AweLand")
    end

    it 'is the best country in the world.' do
      expect(country.rank).to eq("1st")
    end

    it 'has a government.' do
      expect(country.government).to be_kind_of Country::Government
    end

    it 'has symbols.' do
      expect(country.symbols).to be_kind_of Country::Symbols
    end

    it 'has an economy.' do
      expect(country.economy).to be_kind_of Country::Economy
    end

    it 'has an education system.' do
      expect(country.education).to be_kind_of Country::Education
    end

    it 'has a health-care system.' do
      expect(country.healthcare).to be_kind_of Country::Healthcare
    end

    it 'has holidays.' do
      expect(country.holidays).to be_kind_of Country::Holidays
    end

    it 'has a religion.' do
      expect(country.religion).to be_kind_of Country::Religion
    end
end

And here is my implementation for Country class:

# country.rb

class Country
  attr_reader :name, :rank

  def initialize
    @name = "Awesome Land".freeze
    @rank = "1st".freeze
  end

  def government
    @government ||= Government.new(self)
  end

  def symbols
    @symbols ||= Symbols.new(self)
  end

  def economy
    @economy ||= Economy.new(self)
  end

  def education
    @education ||= Education.new(self)
  end

  def healthcare
    @healthcare ||= Healthcare.new(self)
  end

  def holidays
    @holidays ||= Holidays.new(self)
  end

  def religion
    @religion ||= Religion.new(self)
  end

end

Simple and straight forward. I could’ve made it shorter by using Metaprogramming techniques and create code that is DRY:

# country.rb

class Country
  attr_reader :name, :rank

  COMPONENTS = %w(government symbols economy education healthcare holidays religion)

  def initialize
    @name     = "Awesome Land".freeze
    @rank     = "1st".freeze
    @ruller   = "Eki".freeze
  end

  COMPONENTS.each do |m|
    define_method(m) do
      instance_variable_set("@#{m}",Object.const_get(m.capitalize).new(self))
    end
  end
end

Or even using the evil eval:

 COMPONENTS.each do |m|
   eval <<-DEFINE_METHOD
   def #{m}
     @#{m} ||= #{m.capitalize}.new(self)
   end
DEFINE_METHOD
  end

Way shorter right? However I prefer not to use it to keep the code more readable.

Let’s run the test:

  rspec spec/country_spec.rb
...........

Finished in 0.0139 seconds (files took 0.53997 seconds to load)
10 examples, 0 failures

Awesome all the tests passed …

Weighted-Democracy

Remember we mentioned that democracy doesn’t work anymore? Well, after more than two thousand years of coming up with democracy I think we can do better.

We can simply grant people the right to vote, but make the vote unequal. Today, everyone can vote, and this is a little disturbing. You would not want everyone to be a doctor, nor a police officer, so why give these people the power to decide the future of your country? After all, people are equal with their rights, however people are not equal with their contributions.

Now, what criteria would I base the voting power?

First, every adult would have one voting point by the grace of their existence. That’s basic democracy right there. Now, you earn extra points for being a good citizen, so to speak. One point for higher education, one point for knowing design patterns, one point for high income, one point for volunteering in the community, one point for a spotless criminal record, minus one point for having a criminal record, and so forth.

I wont go through all of it and build a perfect one for now as this will take long time, but I’m sure you got the idea. We can make it even more fun by tuning the criteria with small decimal point merits would be things like: smoking, owning pets, number of children, etc.

In the end, everyone would have a vote that mirrors their influence in the society. Which stands to logic. People are not equal, in deeds, intentions, spirit, or influence. Therefore, their votes cannot be equal. In pretty much every single company, senior developer gets more money and more stock options than junior grade developer. Now, no one finds this unfair or unbalanced so it can be applied to society.

In AweLand, good people would get their extra points. While most government simply penalise offenders, they do not reward good citizens, I think this approach is better for personal level and for the community.

Thus, the spectrum of politics would be based on logic rather than breeding, which happens across the world today. The voting in AweLand would rule out the quantity over quality and allow useful people more influence in this world.

Let me try to give a simple example here:

Description label points
Birth birth 1
Higher Education (School) school 1
Higher Education (Bs.C) bsc 1
Higher Education (Master) master 1
Higher Education (PhD) phd 1
High income suc 1
volunteering in community vol 1
crimes crime -1
……. ….. ..

You want to make this more advanced and accurate? Here are three ideas that we can apply to make the weighted democracy system more accurate:

Again, for the sake of simplicity we will stick with the basic here and we will implement that for now following KISS principle, so no Machine Learning will be used so we can keep this article more readable.

I’ll start by creating a Country::Citizen superclass and Country::Adult and Country::Child subclasses. I’ll be using Factory method pattern to build citizen instances.

I’ll use ActiveModel::Model so I can use active_record validations like validates presence: true and more.

To calculate the voting points I’ll be using Country::VotePointsCalculator#calculate.

Let’s start by creating the specs for CitizenBuilder:

describe 'Country::CitizenBuilder' do
    let(:country) { Country.new }

    subject { Country::CitizenBuilder }

    it 'raise error when DOB is not valid.' do
      expect { subject.new(country) }.to raise_error(
        'You need to set Date of Birth (DD/MM/YYYY)'
      )
      expect { subject.new(country, dob: '33/33/2222') }.to raise_error(
        'You need to set Date of Birth (DD/MM/YYYY)'
      )
      expect { subject.new(country, dob: '03/03/2001') }.not_to raise_error
    end

    it 'returns Country::Child instance if age < 18' do
      citizen = subject.new(country, dob: '03/03/2001')
      expect(citizen).to be_kind_of Country::Child
    end

    it 'returns Country::Adult instance if age > 18' do
      citizen = subject.new(country, dob: '03/03/1983')
      expect(citizen).to be_kind_of Country::Adult
    end
end

So based on the date of birth (DOB) I create either Country::Adult or Country::Child subclass. Here is my simple implementation:

require 'date'

class Country::CitizenBuilder

    def self.new(country, params={})
      @dob = params.fetch(:dob) { 'no-dob' }

      validate_attributes
      calculate_age

      params.merge!(country: country)

      return Country::Adult.new(params) if adult?
      return Country::Child.new(params)
    end

    def self.validate_attributes
      begin
        @dob = Date.parse(@dob)
      rescue ArgumentError
        fail('You need to set Date of Birth (DD/MM/YYYY)')
      end
    end

    def self.calculate_age
      @age = Date.today.year - @dob.year
      @age -= 1 if Date.today < @dob.year + @age
    end

    def self.adult?
      @age >= 18
    end
end

I’ll add Country#build_citizen method to delegate to Country::CitizenBuilder:

def build_citizen(params)
    Country::CitizenBuilder.new(self, params)
end

Now let’s implement the specs for Country::Citizen model:

describe Country::Citizen do
    let(:country) { Country.new }

    let(:valid_attributes) {
      {
        country: country,
        name: 'Donald Duck',
        dob: Date.parse('06/08/1971'),
        went_school: true,
        has_bsc: true,
        has_master: false,
        has_phd: false,
        has_crimes: false,
        has_community_work: true,
        yearly_income: 50_000
      }
    }

    let(:citizen) { Country::Citizen.new(valid_attributes) }

    it 'has to be valid with the required attributes.' do
      expect(citizen).to be_valid
    end

    it 'has a country.' do
      expect(citizen.country).to be_kind_of Country
      citizen.country = nil
      expect(citizen).to be_invalid
    end

    it 'has a name.' do
      expect(citizen.name).to eq('Donald Duck')
      citizen.name = nil
      expect(citizen).to be_invalid
    end

    it 'has a date of birth.' do
      expect(citizen.dob).to be_kind_of Date
      expect(citizen.dob).to eq(Date.parse('06/08/1971'))
    end

    it 'validates all the required attributes.' do
      attrs = %w(
        went_school
        has_bsc
        has_master
        has_phd
        has_crimes
        has_community_work
        went_school has_bsc has_master has_phd
      )

      attrs.each do |d|
        citizen.send("#{d}=".to_sym, nil)
        expect(citizen).to be_invalid
      end
    end

    describe '#high_income?' do
      it 'should be numerical value.' do
        citizen.yearly_income = "string"
        expect(citizen).to be_invalid
      end

      context ' > 100_000 annual income' do
        it 'returns true for high_income?' do
          citizen.yearly_income = 120_000
          expect(citizen.high_income?).to eq(true)
        end
      end

      context ' < 100_000 annual income' do
        it 'returns true for high_income?' do
          citizen.yearly_income = 20_000
          expect(citizen.high_income?).to eq(false)
        end
      end
    end

    describe '#points' do
      it 'should delegate to VotePointsCalculator' do
        # We will mock VotePointsCalculator as it's not created yet.

        results = double(:results)
        calculator = double(:calculator)

        allow(Country::VotePointsCalculator)
          .to receive(:new).and_return(calculator)

        allow(calculator)
          .to receive(:call).and_return(results)

        expect(citizen.points).to eq(results)
      end
    end

    context Country::Child do
      let(:child) { Country::Child.new(valid_attributes) }

      it 'can not vote' do
        expect(child.vote?).to eq(false)
      end
    end

    context Country::Adult do
      let(:adult) { Country::Adult.new(valid_attributes) }

      it 'can vote' do
        expect(adult.vote?).to eq(true)
      end
    end
end

And here is the full production code implementation:

require 'date'
require 'active_record'

class Country::Citizen
    include ActiveModel::Model

    HIGH_INCOME = 100_000

    TRUE_FALSE  = %i(
      went_school
      has_bsc
      has_master
      has_phd
      has_crimes
      has_community_work
    )

    attr_accessor :country, :dob, :name, :yearly_income, *TRUE_FALSE

    validates :name, :country, presence: true

    validates *TRUE_FALSE, inclusion: { in: [true, false] }

    validates :yearly_income,
      presence: true,
      numericality: true,
      inclusion: { in: 1_000..1_000_000 }

    def points
      Country::VotePointsCalculator.new(self).call
    end

    def high_income?
      return true if @yearly_income >= HIGH_INCOME
      false
    end
  end

class Country::Child < Country::Citizen
  def vote?
    false
  end
end

class Country::Adult < Country::Citizen
  def vote?
    true
  end
end

Ok now let’s try to make sure my specs are green:

⇒  rspec spec/citizen_spec.rb
..............

Finished in 0.13126 seconds (files took 0.56722 seconds to load)
14 examples, 0 failures

Working like charm. Cool. Now let’s move on to build VotePointsCalculator, this class should be used to calculate the voting score for each voter. I’ll create one main method #call to calculate the points for each citizen following SRP (Single Responsibility Principle). As usual I’ll start by adding some tests:

describe Country::VotePointsCalculator do
    let(:country) { Country.new }

    let(:citizen) {
      country.build_citizen(
        name: 'Eqbal Quran',
        dob: '06/08/1983',
        went_school: false,
        has_bsc: false,
        has_master: false,
        has_phd: false,
        has_crimes: false,
        has_community_work: false,
        yearly_income: 10_000
      )
    }

    subject { Country::VotePointsCalculator.new(citizen) }

    describe '#call' do
      it 'validates citizen object.' do
        subject.citizen.name = nil
        expect { subject.call }.to raise_error(
          RuntimeError,
          "Name can't be blank"
        )

        subject.citizen = 'String'
        expect { subject.call }.to raise_error(
          RuntimeError,
          "Citizen should be a Country::Citizen subclass."
        )
      end

      context 'Citizen can vote (Adult).' do
        it 'get a point by birth' do
          expect(subject.call).to eq(1)
        end

        it 'get a point by having a bachelor degree.' do
          subject.citizen.has_bsc = true
          expect(subject.call).to eq(2)
        end

        it 'get a point by having a master degree.' do
          subject.citizen.has_master = true
          expect(subject.call).to eq(2)
        end

        it 'get a point by having a PhD degree.' do
          subject.citizen.has_phd = true
          expect(subject.call).to eq(2)
        end

        it 'get a point by having a high income.' do
          subject.citizen.yearly_income = 110_000
          expect(subject.call).to eq(2)
        end

        it 'get a point by having some community work.' do
          subject.citizen.has_community_work = true
          expect(subject.call).to eq(2)
        end

        it 'reduce a point by having a crime.' do
          subject.citizen.has_crimes = true
          expect(subject.call).to eq(0)
        end
      end

      context 'Citizen can not vote (Child).' do
        before(:each) do
          allow(subject.citizen).to receive(:vote?).and_return(false)
        end

        it 'raise an error.' do
          expect { subject.call }.to raise_error(
            RuntimeError,
            "Eqbal Quran can't vote."
          )
        end
      end
    end
end

And the implementation for the production code:

class Country::VotePointsCalculator
    attr_reader :points
    attr_accessor :citizen

    def initialize(citizen)
      @citizen = citizen
      @points  = 1 #By birth you get a point
    end

    def call
      validate_citizen
      validate_attributes

      if citizen.vote?
        @points -= 1 if citizen.has_crimes
        @points += 1 if citizen.has_bsc
        @points += 1 if citizen.has_master
        @points += 1 if citizen.has_phd
        @points += 1 if citizen.has_community_work
        @points += 1 if citizen.high_income?
      else
        fail("#{citizen.name} can't vote.")
      end

      @points
    end

    private

    def validate_attributes
      return if citizen.valid?
      fail citizen.errors.full_messages.join(', ')
    end

    def validate_citizen
      return if @citizen.kind_of? Country::Citizen
      fail("Citizen should be a Country::Citizen subclass.")
    end
end

Now let’s try this in action. Bundler has provided us with some handy rake tasks to make installing our in-development gem easy.

⇒  rake install
country 0.0.1 built to pkg/country-0.0.1.gem.
country (0.0.1) installed.

⇒  irb
>> require "country"
=> true

Now let’s try it out:

country = Country.new

citizen_a = country.build_citizen(
    name: 'Eqbal Quran',
    dob: '06/08/1983',
    went_school: true,
    has_bsc: true,
    has_master: false,
    has_phd: false,
    has_crimes: false,
    has_community_work: true,
    yearly_income: 70_000
)

citizen_b = country.build_citizen(
    name: 'Eqbal Quran',
    dob: '06/08/1983',
    went_school: true,
    has_bsc: true,
    has_master: false,
    has_phd: false,
    has_crimes: true,
    has_community_work: false,
    yearly_income: 300_000
)

citizen_a.points # 3
citizen_b.points # 2

Makes perfect sense, This mean that someone with an average income and a good community spirit would have more influence in the final vote with a rich guy who has crime and no community work.

A PhD student with no social favours would get the same points as an ordinary citizen with no criminal record.

Justice has been served :)

Government Components

AweLand will have three main components, I’ll try to briefly mention the components and then discuss each more in details. I’ll discuss the main reason for each component then I’ll suggest the technologies to be used with each module.

Voting Portal:

This is gonna be an online portal for proposing ideas and interacting with the citizens.

Once a PR is opened (proposal get accepted), the E-senator will assign some technical people who has experience building similar proposals. Then the experts can discuss and review the potential changes and shared their experience in a transparent way with the public. Collaborators add comments before the changes submitted and accepted.

While working on the proposal, if some urgent changes needed. A high-level overview of the changes added. The process of agile (review, accept and reject proposal) can cut the cost dramatically. This has been proven efficient in software development and can be applied in building proposals.

PR

E-government system:

The advancement in Information and communication technology (ICT) has affected our relation with people, businesses and more recently with governments.

E-government refers to the use by government agencies of information technologies like wide area network, the internet and mobile computing that have the ability to transform relations with citizens, businesses, and other arms of government. World Bank

In AweLand I’ll be creating an E-government system to to promote more efficient and effective government, facilitate more accessible government services, allow greater public access to information and make government more accountable to citizens. Not bad at all.

To give an example here for the use of E-government, a citizen who wants to know whether citizen with ID=X has been convicted.

Example, I want to know whether citizen with ID=X has been convicted, the response is true/false in this case. Or I want to know the current address of a company with company identifier=X, the response in this case would be an address. This type of services can be used via a standard protocol, so that the consumer doesn’t actually care about where exactly the data is located.

Election system:

Existing electronic election systems all suffer from a serious design flaw: They are proprietary, that is, centralized by design, meaning there is a single supplier that controls the code base, the database, and the system outputs and supplies the monitoring tools at the same time.

The lack of an open-source, independently verifiable output makes it difficult for such centralized systems to acquire the trustworthiness required by voters and election organizers. The blockchain works as a secure transaction database, to log votes and audit vote results in a trustworthy way.

Blockchain

So what is a blockchain database? It is a distributed database that maintains a continuously growing list of ordered records called blocks. Each block contains a timestamp and a link to a previous block.

Why to bother of using it? The transparent and decentralised nature of the blockchain network enables the development of a non-refutable, and unbreakable record of data, which is the fundamental feature that most of us going to explore and apply to our core businesses. I’ll try to explain next how can we use this in our election system and why it could be very useful. But before going through this, let me give a brief intro of why I want to provide this election system.

Since the dawn of democracy, elections throughout the world have been plagued with accusations of illegitimacy. As democratic societies across the globe are beginning to adopt technology to improve the efficiency of the election process, many people are discovering that certain types of technology can be extremely vulnerable, which may have the potential to unfairly influence the outcome of elections.

Using advanced technologies, we will be able to gain transparency into our elections, without compromising voter privacy, and have a way to mathematically prove that the elections results are accurate.

Also, at the voter’s request, there would even be a way to allow a voter to cast their vote online in an election and follow their vote into the ballot box to ensure that their vote was safely and securely stored without being changed or altered in any way.

In the proposed election system, I’ll be used blockchain technologies to acheive all of this. When using the blockchain voting system, the voter submit the appropriate identity information in order to have their identity verified by an Identity Verifier, which would be approved by the organization hosting the election ahead of time. Once their identity is verified, the voter would be able to request their ballot, at which point they are issued their correct ballot type by the Registrar.

The voter would then complete their ballot and securely submit their vote(s) to the blockchain-based ballot box. To obtain proof of casting their ballot, the voter would have the option to print out a receipt. If allowed by the organization hosting the election, the voter may vote early and could even re-enter the Follow My Vote voting booth to change their vote if they change their mind in the days leading up to the election.

When the polls close on Election Day, the most current votes submitted by each voter would be considered the official votes; and, voters would be allowed to follow their vote into the ballot box to ensure that their vote was cast as intended and counted as cast. If they choose to do so, each voter would also be allowed to audit each ballot in the ballot box to confirm the vote totals being reported by the blockchain voting system are accurate, without revealing the identity of each voter. This is pretty cool right?

So, now what is the benefits of using this election system and blockchain technologies in general? I’ll explain the main benefits in general, then I’ll explain the benefits from candidate’s and voter’s prospective.

Symbols

Here I’ll be violating the KISS principle as I want my country to have a powerful and flashy awesome symbols. Why? Let’s check what K. R. Minogue has to say in his book Nationalism (1967):

flags and anthems can be used to create members of a nation by developing new habits and emotions; the “Star spangled banner [U.S. flag] with its stars increasing as a new state joined the Union was an important symbol of America for the millions of immigrants to the United States.

This should help with creating the identity and feel of belonging. These symbols reinforce a national consciousness, create a sense of pride toward national culture, and inspire loyalty toward national political interests.

National symbols would include the following: flags, works of art, national anthems, architecture, postage stamps, passports, and many other forms of media.

I wont include any more tests for this section, as the article is getting long already.

So let’s start here.

Here is my Country::Symbols implementation:

class Country::Symbols < Country::Component

    attr_accessor :heroes, :animals

    def initialize(country, params={})
      super(country)
      @heroes  = params.fetch(:heroes){[
      					'MacGyver', 
      					'Chuck Norris']}
      @animal  = params.fetch(:animal){ 'Dangermouse' }
    end

    def anthem
      # This will only work for OSX
      `open https://www.youtube.com/watch?v=MtN1YnoL46Q`
      puts 'The Duck Song'
    end

    def flag
      %{
        o____
        |\\//|
        |//\\|
        |
        |
      }
    end

    def dance
      faces = [
        "┏(°.°)┛",
        "└( ̄◇ ̄)┐",
        "┗(°.°)┛",
        "┏(°.°)┓",
        "╚(▲_▲)╝",
        "ᕦ(ò_óˇ)ᕤ",
        "(ಠ_ಠ)┌∩┐"
      ]

      "♪#{4.times.map{faces.sample}.join(" ")} ♪"
    end

    def arts
      frames do
        awe_land
      end
    end

    private

    def width
      160
    end

    def random_stars
      10.times do
        random_color = [31,32,33,34].sample
        puts "\e[#{random_color}m#{' '*rand(width)+'*'}\e[0m"
      end
    end

    def new_page
      puts "\e[2J"
    end

    def awe_land
      position = (width/2) - @country.name.size
      puts " "*position +"#{@country.name}"
    end

    def frames(size=99, &block)
      size.times do
        random_stars
        puts block.call
        random_stars
        sleep 0.4
        new_page
      end
    end

end

Now if you wonder what does stuff "\e[31m%s\e[0m" does, it’s just for printing colored outputs in the terminal. Please check out my colleague Toptaller Dennis Krupenik Ruby tip “How to Quickly Color Terminal Print Outputs?” for more details.

Let’s play around with it and see some outputs:

>> symbols = Country.new.symbols
=> #<Country::Symbols:0x007fbf284e9ac8 @country=#<Country:0x007fbf284e9b90 @name="AwesomeLand", @rank="1st", @ruller="Eqbal Quran", @symbols=#<Country::Symbols:0x007fbf284e9ac8 ...>>, @heroes=["MacGyver", "Chuck Norris"], @animal="Dangermouse">
>> s.dance
=> "♪└( ̄◇ ̄)┐ ┗(°.°)┛ ┏(°.°)┓ ╚(▲_▲)╝ ♪"

Sounds good. I’ll leave you to try Country::Symbols#arts to see yourself how cool is AweLand :)

National Holidays

Unlike what you might think, having more holidays could be a good thing. Actually, there should be more holidays. A break boosts morale, so workers would work harder. The same would be true in Japan.

Not taking proper holidays may seem harmless, or even helpful to your career, but be warned: it can also be damaging. “Evidence shows you become less productive without proper breaks. Even if people work longer hours, they’re not as creative and can’t maintain the same intensity level,” says Penny de Valk, managing director of talent management at global HR services group, Penna.

Most people do not use all their annual leave. People feel bad about taking time off. They should not have to feel so. Rather, they should be encouraged to use their annual leave to help them relax. I’m sure this would improve productivity, and people’s quality of life. It’s not about the quantity but the quality of work.

The same conclusion has been made by the creative 37signals team, as they stated in their book Remote:

Working more doesn’t mean you care more or get more done. It just means you work more. Workaholics wind up creating more problems than they solve. First off, working ridiculous hours just isn’t sustainable over time. When the burnout crash comes–and it will—it will hit much harder. Workaholics miss the point, too. Trying to fix problems by throwing sheer hours at them. Trying to make up for intellectual laziness with brute force. This results in inelegant solutions.

In AweLand, I want to take it a step further and make the process more fun and productive.

So citizens will have two type of of holidays, generic and personal holidays.

The genetic will include something like eight-day-long independence week. While the personal holidays will be personalised for each by proving a form to be filled for each citizen. ex: vacation by airing dates for your favourite TV show, as for example I’ll chose Planet Earth and South Park. This way we make the process more productive and fun.

Work week would be five days for most jobs, four days for some, no overtime allowed.

Retirement age would be 60, but people would be allowed to continue working.

The country would permit professional or skilled workers immigration. Foreign investment in real estate and high-tech industry would be encouraged, but the economy laws would be enforced.

Civil liberties

The country would be as liberal as it gets on one hand and as strict as possible, on the other.

For example, corporal punishment would be allowed alongside free abortion and two-year maternity leaves. The punishment would include the standard array of capital punishment, but also things like assaulting elderly, torturing animals, and more.

There would be no discrimination, with men-only or women-only duties. The same applies to all emergency services, including firefighting, police, and others.

Movies would have to be screened in their original language, with subtitles provided. Dubbing would be disallowed.

Modding cars with tailpipe rattle, “NO FEAR” stickers or similar nonsense would be disallowed.

And Internet would be free! There would be no stupid regulation supervisions of any kind. In fact, citizens would have to share using P2P, but only approved material would be allowed for sharing, mostly free and open-source stuff, like Linux distributions.

Sharing of copyrighted material would be included in the government education bill, with everyone paying a mandatory monthly fee. Proceedings would go to copyright owners, while users would enjoy instant access to culture and entertainment.

There would be a mandatory break for yoga or football at the workplace.

Children

People would be granted a parenting license, after proving they are capable of raising children. Tests would be based on a few simple factors, including basic intelligence, education, criminal past, profession, and others.

Depending on the test outcome, parents would be granted children points. For example, an average middle-class family would be permitted two children. This means they would be provided with all the benefits the country provides, like extensive maternity leaves, children grants and so forth.

If a family decided to have more than their allotted quantity, they would either not receive additional benefits or even be fined for breaching the civil status quo.

Domestic housekeeping would be recognised as a full-time job with all its benefits.

Healthcare & education

Healthcare and Education would be free, including a promised job opportunity for university graduates. In addition to voting favors that education brings, there would also be handsome scholarships and grants.

Twelve years of education would be mandatory. Trades with apprenticeships would also be recognized as valid substitution to formal education. Udacity and other certificates would be officially regonzied.

At least one and possibly two foreign languages would be taught.

Real-life education would also replace some of the classic subjects that no one cares about. Classic literature, which is simply depressing and too difficult for children would be replaced with fun books like Lord of the Rings and Harry Potter.

There would be some mandatory volunteering for children, like helping elderly three hours a week or so.

Economy

Providing third party transactional trust at scale has been the business of banks and brokers since the Medicis gained extraordinary international power by revolutionizing banking in the 14th century. Since then, we haven’t changed much and this always caused us much troubles.

So, how can we solve this problem in AweLand?

We discussed Blockchain technology earlier in the article, and here I will explain how can we use the same decentralised technology to improve the economical aspect of AweLand.

In AweLand we want transference of trust, data, and ownership infrastructure from banks and businesses into distributed peer to peer network protocols. This technology, cryptically named the blockchain is embodied in several distributed networks such as Bitcoin and Ethereum.

In block chain systems, account identity and transactions are cryptographically verified by network “consensus” rather than by trust in a single third party.

Currencies are not the only assets that can be traded on block chain protocols. Distributed user accounts are the most basic element of the cryptographic network infrastructure. The next wave of innovation is in the transference of asset ownership of all types.

Blockchains allow the digital payments layer the Internet never had, and more broadly contemplate an era whereby all forms of secure value transfer could take place via the Internet.

This could include all monetary assets (the cash or spot market), and all assets and liabilities over any future time frame (the futures and options market, mortgages, debt and equity securities, treasury issuance, and public debt).

In AweLand:

To know more about cryptocurrency I would recommend reading cryptocurrency for dummies bitcoin and beyond book.

In AweLand, we will make teaching Resource Based Economy as a mandatory subject in school’s curriculum. In order for us to be able to make the transition to this new, more humane society a quantum leap in both thought and action is required.

So, if you are confused all about the Resource Based Economy, let me try to briefly explain Jacque Fresco’s idea it.

The idea behind RBE is that in modern society, we have access to highly advanced technology and can make available food, clothing, housing and medical care; update our educational system; and develop a limitless supply of renewable, non-contaminating energy. By supplying an efficiently designed economy, everyone can enjoy a very high standard of living with all of the amenities of a high technological society. The term and meaning of a Resource Based Economy was originated by Jacque Fresco.

It is a whole factor socio-economic system in which all goods and services are available without the use of money,

At present, we have enough material resources to provide a very high standard of living for all of Earth’s inhabitants. So, why no one is using it?

I think the major issue here is psychological, and that’s why I suggested make teaching RBE as mandatory in schools. The thought of eliminating money still troubles us, consider this: If a group of people with gold, diamonds and money were stranded on an island that had no resources such as food, clean air and water, their wealth would be irrelevant to their survival. It is only when resources are scarce that money can be used to control their distribution. One could not, for example, sell the air we breathe or water abundantly flowing down from a mountain stream. Although air and water are valuable, in abundance they cannot be sold. Money is only important in a society when certain resources for survival must be rationed and the people accept money as an exchange medium for the scarce resources. Money is a social convention, an agreement if you will. It is neither a natural resource nor does it represent one. It is not necessary for survival unless we have been conditioned to accept it as such

As Jacque Fresco explained, behaviour can be modified that’s why in AweLand we will increase the awareness of the system, and hopefully we will move to a resource based economy instead of the current monetary system once we are ready.

Power

Solar Power, Wind Power, Ocean Thermal Energy Conversion, Hydroelectricity, Biomass, Tidal Power, Wave power, Geothermal Power, Hydrogen, Propane and all kind of renewable are good sources of energy, however in AweLand we can do even better.

Fusion Energy is what is gonna be used in AweLand. It may not be renewable energy, but it still may be a power source for our future.

It’s produced when hydrogen reaches a temperature in excess of 100 million degrees Celsius. At that point, the hydrogen is contained in a high-powered magnetic confinement system, where positively charged hydrogen atoms, stripped of their electrons, fuse to form helium. This fusion produces energy.

An international research team is setting out to design and possibly operate the world’s first electricity-producing fusion power plant. It could produce energy around year 2027 at the earliest, but scientists are trying to think of a faster way to develop fusion energy as a viable source. Not bad at all.

Another alternative, would be a wind-solar hybrid on steroids. Plans are already afoot to build a massive 2,235-foot-tall tower in the Arizona desert that would produce clean energy. A series of pumps would send water to the top of the tower. The water would be injected out into a tunnel opening that’s part of the tower, creating a mist. There, the mist would mix with dry, desert air that had been heated by the sun. That dry air would absorb the water particles and become heavy, causing it to fall through the tunnel, creating wind that spins turbines at the base, which then power generators to produce electricity.

As long we are not using fossil fuel in AweLand.

Foreign policy

AweLand would be a proud member of various global assemblies, but refuse to cooperate citing bureaucracy difficulties, just to spite everyone.

In general, AweLand would favor more modern and progressive countries, but it would exercise no moral superiority on any subject or pretend to know what’s best for everyone elsewhere. As such, it would have a strict rule of no military intervention anywhere in the world. However, it would automatically blacklist countries that discriminate people based on race or Religion.

Religion

The problem with some religions is that they were used for centuries to govern people and thus the religious organization itself started gaining power and control over people. This created a breed of people within those religions obsessed with that power and control over others, and it has skewed them to varying degrees further in the direction of making a religion absolute and decreeing. Ironically, such efforts are largely in direct conflict with what the original intent of the respective religion was.

In general, public practice of religion would be banned. Personal, at home practice would be allowed. There would be no government-sanctioned sponsorship of religious bodies of any kind.

Religious institutions would be not be allowed to register as charities or volunteer organizations, either.

To sum it up, in a self-explanatory Ruby code:

class AweLand
  def religion
	  raise(AweLand::Religion::Error::PublicPractiseNotAllowed)
  end
end

Or even easier:

class AweLand

  private
  def religion
  end
end
>> AweLand.new.religion
NoMethodError: private method `religion' called for #<AweLand:0x007fcd4a06bcf0>
	from (irb):7
	from /usr/bin/irb:12:in `<main>'

Resource Distributions

Machine Learning (ML) and Artificial Intelligence (AI) algorithms should be used extensively with distributing scarce resources (goods and services) in AweLand.

Our current economic system focuses on in a free market matching of demand and supply of scarce goods and services produced in society by primary production factors nature and labor and secondary production factor capital. But that’s theory; the reality is different.

The economic system is controlled by social systems. Marketing, advertising, social media and income inequality, manipulate the needs and desires of the people. Carefully managed scarcity leads the ‘free’ market, which should independently regulate demand and supply.

The economic system will not work as the intended distribution mechanism whereby the money runs opposite to the flow of goods but begins to degenerate into a money pump, which hunts the money into one direction. The economic system is broke. With the disappearance of labor as a factor of production, also disappears the basis for the division of labor and thus the structure of our socioeconomic system. The economic system must evolve towards a system where scarcity and abundance are distributed in a technological way.

AI, however, is capable of analyzing data to find out which ad to present to each customer, then with the same intelligence it can also steer the production and distribution of goods and services directly. This technology can learn to work along with the earth systems rather than just rely on the wishes of customers.

A free market competition and costly marketing are no longer necessary. Not the competition to earn money, but the information about the behavior of people and ecosystems forms the basis for controlling the economic system.

No planned economy, lead by the government, but an intelligent system based on the data. Collecting the data would then not be limited to data on the (manipulated) human behaviour and the economic system, but also include the data in the ecosystems. And that would make distributing goods and services way more efficient that what is used in the current monetary system.

Transportations

Autonomous driving mood, will be the main medium for transportations in AweLand. Human driving mood will be highly taxed in in Aweland.

81 percent of car crashes are the result of human error, computers would take a lot of danger out of the equation entirely. Computers use complicated algorithms to determine appropriate stopping distance, distance from another vehicle and other data that decreases the chances of car accidents dramatically.

When a computer takes over the driving responsibilities, drivers can use that time to do other things, like catch up on reading or chat with passengers, all without having to worry too much about road safety.

Allowing computers and to take control of driving, would significantly improve traffic conditions and congestion. This would help to reduce commute times for drivers in high-traffic areas but also to maximize on gasoline usage.

Singapore already started to use the self-driving taxis, and to pick up passengers.

Dubai, just started to use autonomous drone that can transport humans as a self-flying taxis too.

Conclusion

In a nutshell, that’s the perfectest country ever designed. It would be the ultimate punch in order, efficiency, obedience, happiness, and overall quality.

In AweLand, we used what technology offers to design a more efficient country.

It would be based on logic and productivity. No longer would the senseless mass called people rule, but people properly guided and goaded and whipped.

The weighted rule democracy along with blockchain technology, would be awesome, so much better than its classic one-vote counterpart. Not only would it maintain its stability, it would also gain from additional factors that are completely disregarded today, like the actual individual impact and influence on the society.

Combined, the economy, the foreign policies, healthcare, education, and civil liberties make AweLand the new Utopia that works so much better than the naive, daydreaming ideals of olden philosophers, who believed in the betterment of mankind.