• The ability to retrieve mail from POP3 (while leaving the mail on the server) and IMAP.
• Display of plain-text email, ability to save attachments.
• The ability to enter the from-address in a text field (and not a drop-down from a list, even if that list is editable) when sending email.
• The ability to display mail in a graphical table view, sortable on received date, sender, topic.
• The ability to store mail client-side in a tree-like/directory structure, with rules to decide which mail goes to which node.
• The ability to see, and filter on, the actual target email from the trusted Received: header (IE the email address used in the RCPT command to the trusted SMTP, not the envelope target) preferably without having to manually eyeball it out of the headers of the emails.
• The ability to block/ HTML and images in incoming mail.

Please suggest to me mail clients that fulfil ALL of these requirements. Register and comment on this post, or send suggestions to

(or let me know on IRC or Facebook if you know me there).

Things that would be nice to have in addition:

• Free and open source.
  • Written in Java
• Listed with each mail: the server, protocol, and username used to download it.
• Simple scripting interface.
• RSS support
• User-friendly encrypted and signed email support.

[06:56] [_W_] Bjorn, but who cares if you get to remove one liar if you’re just replacing him with another?
[06:56] <Bjorn> I don’t think obama is a liar
[06:57] <Bjorn> I think clinton was a liar but that didn’t bother me then
[06:57] <Bjorn> he bothers me now though
[06:57] [_W_] Bjorn, are you really that blind?
[06:57] <Bjorn> see we settled for clinton then because there wasn’t anything better
[06:57] <Bjorn> _W_: blind to what?
[06:57] <Bjorn> you think Obama is a liar?
[06:58] [_W_] absolutely
[06:58] <Bjorn> well, I disagree
[06:58] <Bjorn> whole heartedly
[06:58] [_W_] as is anyone likely to get even close to a presidential nomination
[06:58] <Bjorn> I think anyone who thinks he is a liar is either ignorant or jaded
[06:58] [_W_] Bjorn, you’ll see

One of Obama’s pledges (http://www.barackobama.com/2007/08/01/the_war_we_need_to_win.php)

As President, I will close Guantanamo, reject the Military Commissions Act, and adhere to the Geneva Conventions. Our Constitution and our Uniform Code of Military Justice provide a framework for dealing with the terrorists.

http://en.wikipedia.org/wiki/Habeas_corpus

Obama on prosecuting for torture (http://www.philly.com/philly/blogs/attytood/Barack_on_torture.html)

…if crimes have been committed, they should be investigated.

http://en.wikipedia.org/wiki/Nuremberg_Principles

First the idea gay rights depends on sexual preference being a determined trait and not a choice. “It’s not a choice” is sometimes used as a blanket defense against homosexuality being a sin, or being immoral. If you suggest that sexual preference might be a choice, or that the evidence isn’t compelling either way, you are often opposed by people that assume you are going to argue that since it might be a choice, we should try to decrease the number of homosexuals, or are told to not promote that line of thinking to give religious fundamentalists more fuel for their arguments. But this is dishonest thinking. Whether sexual preference is a choice or not doesn’t affect what rights homosexuals should have. So what if it is a choice? Homosexuality harms no one. It is not something to be fought or eliminated. I would rather Christian and Muslim fundamentalists thought I were doing wrong, and engaged me in rational debate to try to convince me, rather than think me ill or damaged, to be fixed, rather than reasoned with. Gay rights stands on its own merits, and homosexuality does not need excuses.

Next the slippery slope argument. And this goes both ways. There’s a lot of people saying that if we allow gay marriage, we must allow polygamy, and acts of bestiality, incest, pedophilia, and so on. That many of the arguments for gay rights are at their core arguments for sexual freedom of many kinds. On that last, they are right! But that in and of itself is not an argument against gay rights. If an argument seems to apply to both gay marriage and polygamy, that does not mean that all the arguments that might exist against polygamy are applicable to gay marriage. If you think polygamy is wrong and should be fought against, and someone makes an argument for gay marriage that might also apply to polygamy, you should not fight the argument on that basis, but find your arguments against polygamy, and see if they are applicable to gay marriage as well! But more importantly, gay rights proponents should not shy away from other sexual freedoms merely because they don’t want public opinion against themselves. Rational debate must come first, and using dishonest and irrational argumentation only hurts the cause in the long run. If someone says “if we allow gay marriage, why not pedophilia as well?” a good answer is “because children can’t consent, while homosexuals can”, not vague or misleading arguments like “there is no slippery slope” “those are two different things” or emotive arguments like “are you comparing me do a pedophile?!” At the same time we have to be open to the idea that if society is (or have been) wrong about homosexuality, it might be wrong about incest, or polygamy, as well. Each step has to be argued on its own, without conflating the various liberties into one.

And last one that is unique to gay rights opponents. Parenting, and a child’s rights. There’s a lot of arguments these days that a child needs both a mother and a father, and that just two parents of the same gender isn’t enough. Or that we don’t know enough about how same-gendered parents affect children, so we shouldn’t experiment. There are several problems with this kind of thinking. The first is that all these arguments apply equally to either single parents, be it divorced parents, an unknown father, or even a widow or widower; economically poor parents; or foster or adopting parents. There is no argument for allowing these kind of parents that does not equally argue for allowing same-sexed parents. The other is that all parenting is a gamble. There is never any guarantee that parents will raise their kid well. I bet every single parent feel the fear that they won’t be doing right by child, and an uncertainty of how their child will turn out despite their efforts. There is no deterministic “good parent” button, and especially not one that heterosexual couples have exclusive access to. Every single child raised is an experiment.

So why not just use the windows build, you ask? Well, there’s the small detail of an EULA you have to agree to. A fairly nasty EULA, in fact. One which grants Google the right to use any of your content that you transmit through, or display on, Google Chrome.

Don’t believe me? Read the following carefully, quoted from http://www.google.com/chrome/intl/en-GB/eula_text.html

Google Chrome Terms of Service

These Terms of Service apply to the executable code version of Google Chrome. Source code for Google Chrome is available free of charge under open source software licence agreements at http://code.google.com/chromium/terms.html.

1. Your relationship with Google

1.1 Your use of Google’s products, software, services and websites (referred to collectively as the “Services” in this document and excluding any services provided to you by Google under a separate written agreement) is subject to the terms of a legal agreement between you and Google. “Google” means Google Inc., whose principal place of business is at 1600 Amphitheatre Parkway, Mountain View, CA 94043, United States. This document explains how the agreement is made up and sets out some of the terms of that agreement.

---

2. Accepting the Terms

2.1 In order to use the Services, you must first agree to the Terms. You may not use the Services if you do not accept the Terms.

2.2 You can accept the Terms by:

(A) clicking to accept or agree to the Terms, where this option is made available to you by Google in the user interface for any Service; or

(B) by actually using the Services. In this case, you understand and agree that Google will treat your use of the Services as acceptance of the Terms from that point onwards.

---

9. Proprietary rights

---

9.4 Other than the limited licence set forth in Section 11, Google acknowledges and agrees that it obtains no right, title or interest from you (or your licensors) under these Terms in or to any Content that you submit, post, transmit or display on, or through, the Services, including any intellectual property rights that subsist in that Content (whether those rights happen to be registered or not, and wherever in the world those rights may exist). Unless you have agreed otherwise in writing with Google, you agree that you are responsible for protecting and enforcing those rights and that Google has no obligation to do so on your behalf.

---

11. Content licence from you

11.1 You retain copyright and any other rights that you already hold in Content that you submit, post or display on or through the Services. By submitting, posting or displaying the content, you give Google a perpetual, irrevocable, worldwide, royalty-free and non-exclusive licence to reproduce, adapt, modify, translate, publish, publicly perform, publicly display and distribute any Content that you submit, post or display on or through the Services. This licence is for the sole purpose of enabling Google to display, distribute and promote the Services and may be revoked for certain Services as defined in the Additional Terms of those Services.

11.2 You agree that this licence includes a right for Google to make such Content available to other companies, organisations or individuals with whom Google has relationships for the provision of syndicated services and to use such Content in connection with the provision of those services.

11.3 You understand that Google, in performing the required technical steps to provide the Services to our users, may (a) transmit or distribute your Content over various public networks and in various media; and (b) make such changes to your Content as are necessary to conform and adapt that Content to the technical requirements of connecting networks, devices, services or media. You agree that this licence shall permit Google to take these actions.

11.4 You confirm and warrant to Google that you have all the rights, power and authority necessary to grant the above licence.

Emphasis mine. Seems fairly clear cut to me… Artists, authors, developers etc. should beware of using Google Chrome for any of their work, even just test-viewing it.

Now, what Google can actually do with their licence, or how they will know what content they actually have a right to, I don’t know. If I could run their software without agreeing to this EULA, I could probably detect any attempt to call home, and so could thousands of other people, so I doubt they’re quite that brash about it. But the legal right alone is disturbing.

Update

Google has now adknowledged that this was a mistake in adapting an existing EULA, and have removed the offending 11.1 paragraph.

Copyleft is an idea popularized by GNU and the Free Software Foundation, that claims to work towards ensuring certain freedoms when it comes to software, by publishing software under the GNU General Public License (GPL), that has as one of its main points that derivative works can only be distributed under the same or a compatible license.

The problem is that people might want to release their source code under a freer license, but also wish to not reinvent code already released under the GPL. The GPL thus cause extra work for the principled programmer, who will have to laboriously write new code to do exactly the same that the GPL code does, while being careful not to copy, or base the design of the new library, on the old one. In the worst case such a task is too much, and innovation that would otherwise happen fails to come about, and everyone is impoverished as a result.

Richard Stallman raves against “software hoarding”; companies that take some free product, adds in their own innovations, and releases the result with a more restrictive license, commercially. He writes that this makes software less free. Which is just plain wrong. Because if someone takes free software A, improves it, and releases unfree software B, the world has more freedom. Software A does not go away, everyone can still use and base their improvements on that piece, ignoring B, but in addition they also have the choice of using B. The company that makes B might not be very nice, they are accepting a gift, and not giving back in turn. But they are still doing some good, they are still innovating. Their ideas, if not their code, can be utilized in free software. (Granted that software patents, an even greater evil than copyrights, don’t apply.)

The GNU GPL works within current law. It strongly relies on copyrights. To enforce it, the laws and law enforcement mechanisms are utilized. If the copyright laws were weakened, the GPL would lose some of its power. The GPL thus gives programmers who have released under the license an incentive to work towards upholding copyright laws. But copyright laws are inherently dangerous; the law essentially dictates what Joe Hacker and Bob Hacker can do with their own personal property, their own computers. To enforce such a thing, law enforcement must be able to detect when Joe distributes some piece of information to Bob. The transfer might be encrypted for privacy, so now law enforcement has to have a way to force encryption keys from suspects, or encryption must be banned entirely. The transfer might be on a completely private network, so now law enforcement has to have a way to tell when any person is communicating with any other through privately owned equipment, or networks must be forced to register its traffic with authorities, and hidden networks banned. Giving law enforcement such powers, or banning such things, violates basic civil and human rights.

An ethical programmer will avoid assist in maintaining copyrights. He will release the code he writes on his own into the public domain. He will help write libraries that duplicate what GPL and proprietary libraries do, but this time, make them really free. And he will be free to lobby for weakening copyright laws and the enforcement thereof, free to acts of civil disobedience that undermines copyrights, and free to stand up for the basic rights of privacy and presumption of innocence.

Let us list a few minimal Pythagorean circles, and their radius squared:

Now looking at R^2 you might notice a pattern. Lets see the factorizations of the radius squared of these minimal Pythagorean circles:

Now, the challenges: What is the next prime factor to show itself in this kind of factorization? What is the minimal Pythagorean circle for degree 11 and 13? What is the complete pattern, and is there a formula for finding the minimal Pythagorean circle for a given degree?

Update: added this diagram of a pythagorean circle of degree 3, with radius squared 25 (and radius 5):

Update2: a hint is that no sum of two square numbers can be written as 4x+3, where x is integer

/*
 * This code is written by W (aka Raymond Wold) and is released into the public domain.
 *  - It's not my code, I just wrote it.
 */
package com.w_wins.fizzbuzz;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public class FizzBuzz implements Runnable{
    private final Facilitator<Integer, String> facilitator;

    public FizzBuzz(){
        final List<ConditionalAdaptor<Integer, String>> list=new ArrayList<ConditionalAdaptor<Integer, String>>();
        final FizzBuzzConditionFactory fizzBuzzConditions=new FizzBuzzConditionFactory();
        list.add(fizzBuzzConditions.generateFizzBuzzAdaptor());
        list.add(fizzBuzzConditions.generateFizzAdaptor());
        list.add(fizzBuzzConditions.generateBuzzAdaptor());
        facilitator=new Facilitator<Integer, String>(list, new ToStringAdaptor<Integer>());
    }

    @Override
    public void run(){
        facilitator.runOn(new IntegerRangeGenerator(1, 100), new Outputter());
    }
}

interface Adaptor<F, T>{
    public T convert(F value);
}

interface Condition<V>{
    public boolean matches(V value);
}

interface ConditionalAdaptor<F, T> extends Adaptor<F, T>,Condition<F>{
}

interface Handler<T>{
    public void handle(T value);
}

class Facilitator<F, T>{
    final List<ConditionalAdaptor<F, T>> conditionalAdaptors;
    final Adaptor<F, T> finalAdaptor;

    public Facilitator(final List<ConditionalAdaptor<F, T>> conditionalAdaptors, final Adaptor<F, T> finalAdaptor){
        this.conditionalAdaptors=conditionalAdaptors;
        this.finalAdaptor=finalAdaptor;
    }

    public void runOn(final Iterator<F> iterator, final Handler<T> handler){
        while(iterator.hasNext())
            handler.handle(runAdaptors(iterator.next()));
    }

    public T runAdaptors(final F value){
        for(ConditionalAdaptor<F, T> adaptor : conditionalAdaptors)
            if(adaptor.matches(value)) {
                return adaptor.convert(value);
            }
        return finalAdaptor.convert(value);
    }
}

class ConditionConditionalAdaptor<F, T> implements ConditionalAdaptor<F, T>{
    private final Condition<F> condition;
    private final Adaptor<F, T> adaptor;

    public ConditionConditionalAdaptor(final Condition<F> condition, final Adaptor<F, T> adaptor){
        this.condition=condition;
        this.adaptor=adaptor;
    }

    @Override
    public boolean matches(F value){
        return condition.matches(value);
    }

    @Override
    public T convert(F value){
        return adaptor.convert(value);
    }
}

class AndCondition<V> implements Condition<V>{
    final List<Condition<V>> conditions;

    public AndCondition(final Condition<V> a, final Condition<V> b){
        conditions=new ArrayList<Condition<V>>();
        conditions.add(a);
        conditions.add(b);
    }

    public AndCondition(final List<Condition<V>> conditions){
        this.conditions=conditions;
    }

    public AndCondition(final Condition<V>[] conditions){
        this.conditions=Arrays.asList(conditions);
    }

    @Override
    public boolean matches(V value){
        for(Condition<V> condition : conditions)
            if(!condition.matches(value)){
                return false;
            }
        return true;
    }
}

class FizzBuzzConditionFactory{
    private static final String FIZZ="Fizz",  BUZZ="Buzz";
    private final Condition<Integer> fizzCondition,  buzzCondition;

    public FizzBuzzConditionFactory(){
        fizzCondition=new IntegerDivisibleBy(3);
        buzzCondition=new IntegerDivisibleBy(5);
    }

    public ConditionalAdaptor<Integer, String> generateFizzBuzzAdaptor(){
        return new ConditionConditionalAdaptor<Integer, String>(new AndCondition<Integer>(fizzCondition, buzzCondition), new FixedStringAdaptor<Integer>(FIZZ+BUZZ));
    }

    public ConditionalAdaptor<Integer, String> generateFizzAdaptor(){
        return new ConditionConditionalAdaptor<Integer, String>(fizzCondition, new FixedStringAdaptor<Integer>(FIZZ));
    }

    public ConditionalAdaptor<Integer, String> generateBuzzAdaptor(){
        return new ConditionConditionalAdaptor<Integer, String>(buzzCondition, new FixedStringAdaptor<Integer>(BUZZ));
    }
}

class FixedStringAdaptor<T> implements Adaptor<T, String>{
    private final String string;

    public FixedStringAdaptor(String string){
        this.string=string;
    }

    @Override
    public String convert(T value){
        return string;
    }
}

class IntegerDivisibleBy implements Condition<Integer>{
    private final int modulo;

    public IntegerDivisibleBy(final int modulo){
        this.modulo=modulo;
    }

    @Override
    public boolean matches(Integer value){
        return value%modulo==0;
    }
}

class ToStringAdaptor<T> implements Adaptor<T, String>{
    @Override
    public String convert(T value){
        return value.toString();
    }
}

class IntegerRangeGenerator implements Iterator<Integer>{
    private int current;
    private final int end;

    public IntegerRangeGenerator(final int fromInclusive, final int toInclusive){
        this.current=fromInclusive;
        this.end=toInclusive;
    }

    @Override
    public boolean hasNext(){
        return current<=end;
    }

    @Override
    public Integer next(){
        if(!hasNext()) {
            throw new NoSuchElementException();
        }
        return current++;
    }

    @Override
    public void remove(){
        throw new UnsupportedOperationException("The integers are a fixed set");
    }
}

class Outputter implements Handler<String>{
    @Override
    public void handle(final String value){
        System.out.println(value);
    }
}

    public static enum FizzBuzz{
        FIZZBUZZ(true,true,false){
            protected boolean matches(final int t){
                return t%15==0;
            }
        },FIZZ(true,false,false){
            protected boolean matches(final int t){
                return t%3==0;
            }
        },BUZZ(false,true,false){
            protected boolean matches(final int t){
                return t%5==0;
            }
        },NUMBER(false,false,true){
            protected boolean matches(final int t){
                return true;
            }
        };
        private final boolean fizz,buzz,number;
        protected abstract boolean matches(int t);
        FizzBuzz(final boolean fizz,final boolean buzz,final boolean number){
            this.fizz=fizz;
            this.buzz=buzz;
            this.number=number;
        }
        
        public void printNumber(final int t){
            if(fizz)System.out.print("Fizz");
            if(buzz)System.out.print("Buzz");
            if(number)System.out.print(t);
            System.out.println();
        }
        
        public static FizzBuzz getFizzBuzz(final int t){
            for(FizzBuzz fizzBuzz:FizzBuzz.values()){
                if(fizzBuzz.matches(t)){
                    return fizzBuzz;
                }
            }
            throw new Error("Can't happen");
        }
    }
    
    public static void fizzbuzz5() {
        for(int t=1;t<=100;++t){
            FizzBuzz.getFizzBuzz(t).printNumber(t);
        }
    }
}


Comment

Oh life is a glorious cycle of song,
A medley of extemporanea;
And love is a thing that can never go wrong:
And I am Marie of Roumania.

--Dorothy Parker

With some utility classes to wrap things up neatly, the code to read in, say, an XML configuration file, is as easy as this:

public void main(String[] args){
    Configuration config=new Unmarshaller<Configuration>("config.xsd",Config.class).unmarshall();
    Socket socket=new Socket(config.getHostname(),config.getPort());
    for(Configuration.User user:config.getUser()){
        // Do something with the user object....
    }
}

Anyway, Java was not what I was going to write about. It’s just that coding Java, and being reliant on XSD files, I get into contact with some of them written by others. Whether it’s people wanting help on IRC channels I frequent, or a partner system at work that my code has to interface with, I have to read the schema and try to understand it. To get to my point, let me show you two examples.

First example

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">

<xs:element name="note">
    <xs:complexType>
      <xs:sequence>
	<xs:element name="to" type="xs:string"/>
	<xs:element name="from" type="xs:string"/>
	<xs:element name="heading" type="xs:string"/>
	<xs:element name="body" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
</xs:element>

</xs:schema>

Second example

<?xml version="1.0"?>
<schema xmlns             ="http://www.w3.org/2001/XMLSchema"
        targetNamespace   ="http://www.w3schools.com"
        elementFormDefault="qualified">
  <element name="note">
    <complexType>
      <sequence>
	<element name="to" type="string"/>
	<element name="from" type="string"/>
	<element name="heading" type="string"/>
	<element name="body" type="string"/>
      </sequence>
    </complexType>
  </element>
</schema>

The first example is from W3schools schema howto, the second is my improved version. Now, besides the better indentation, what was my main improvement? I removed the prefix for the XMLSchema namespace! This is something I see all over the place. Guides and tutorials all over the net do the same, and newbies mimic it.

XML has some attributes that start with xmlns; these have a special meaning. xmlns:something=”http://something.else/” defines a namespace prefix, “something” that is an alias for the namespace “http://something.else/”. This is a way to specify what namespace a tag belongs to. When you later write <something:a/> (given that that a is a descendant of the element where you defined the prefix), that declares that the a tag belongs to the “http://something.else/” namespace. But it is only a way to specify namespaces. Typing prefixes everywhere gets tiresome, and it makes the text harder to read. And having the text easy to read for a human is one of the key goals of XML, and a great benefit of it. So there’s an alternative method. You can just say xmlns=”http://something.else/” and that tag and every tag within it is of the namespace “http://something.else/”! Of course, if you need to mix namespaces, you typically use prefixes. But you can use xmlns for the most prevalent namespace, and the prefixes for the exceptions, or if one namespace set is nested wholly within another, just use the xmlns attribute twice.

So why do people keep asking for help with overly ugly schemas, with documents with a prefix on every single tag? Why do tutorials and guides do the same? I think the problems is merely a lack of understanding of namespaces. People are just doing what the people before them did, without an understanding of WHY those special attributes are what they are, or what those letters before the tag mean. Like the cults that have given cargo cult programming their name, they are merely copying the visible efforts that seem to give the right results, without an understanding of what makes them work.

Don’t be that way. Namespaces might be more complex than the simplicity of tags and attributes, but they aren’t that hard to use. Take the time to learn how they work, and how you declare them. Not only will your documents be much more readable and you’ll be typing less, but you will have learned an important part of what makes XML tick, gained a better understanding of it.