Robert Fischer

Choose Your 9/11 September 11, 2012 | 06:00 am

Each year, when 9/11 rolls around, we are given a choice between two 9/11s. One is a 9/11 which is borne on and fuels hatred and division in our world. The hatred and division of September 11th expressed itself by transforming planes full of innocent people into missiles of war. Airplanes, instruments of peace and industry, became instruments of war and death — plowshares turned into swords.

The instantaneous creation of three thousand victims shocked us. It led the politicians of the United States of America, like the elders of Israel in 1 Samuel 8, to call for a strong leader who could lead us into war. In the face of so many innocent deaths, we offered patriotic prayers. We turned to violence and war. We would eradicate the hatred of us by killing those who hate us.

Like Samuel, some prophets of our age warned us about what we were doing, what we were giving up, and what we were taking on. The prophets warned us that succumbing to fear would transform the USA into a country where hate and bigotry become powerful and influential forces. They warned us that the economic toll of the military’s needs would be disastrous to our nation’s struggling livelihood. They warned us that the consolidated power would be abused, invasive, and turned to the ends of the powerful against the good of the populace. They warned us that thousands upon thousands would join the three thousand who died on that day. Despite warnings, we still called for a strong leader to lead us to war: someone who could save us from this threat, who would keep us safe and be our salvation. Just as when the Israelites were calling for a king, God granted us our wish and the prophetic warnings have come to pass.

On this anniversary, the wounds are fresh again. The images of terror and panic are new in our minds all over again. Relived traumas reinforce the pain. We also have the additional weight of our past decisions that tripled the count of dead through our direct actions. The weight presses the pain deeper into our psyche. It is oppressive.

On this anniversary, we have a chance to take a new choice. We cannot change the past, but we can take the pain we feel in the present and use it to make a better future: one of peace, one powered by a force more powerful than hatred and division. We can learn how to do that by looking to another anniversary commemorated today. The other anniversary is of an event one hundred and six years ago today.

One hundred and six years ago today, another war started. This war was a new kind of war, a war that demonstrated that there was a force more powerful than tanks and mortars. The new war was based on faith in God, on faith in the power of martyrdom and truth to prevail over the most despicable and systematic acts of humanity’s sin.

The Muslim people who make up Afghanistan were key and powerful soldiers in this faithful war. This war drew one hundred thousand Muslims of the area into a movement called the Servants of God, dedicated to building up the destitute and to gaining freedom against a deadly oppressor. This new way of waging war converted the people of Afghanistan, then violent resistors and victims of oppression, into a force for peace and social betterment. This new way of waging war all started one hundred and five years ago, on the other 9/11.

The other 9/11 is when a man named Mohandas Ghandi launched of a new kind of war: one called “Clinging to Truth”. Believing that people are fundamentally relational, this war is based on exposing the truth of a situation and forcing people to cope with it. Exposing the truth of a situation may mean accepting violence done upon you without returning any in kind, a shocking concept in our age of industrialized state-advocated killing. Yet there is a tremendous and well-proven power in the witness of innocents, and in the power of innocence to triumph over death. Waging war through witness and relationship freed three hundred and fifty million people, and rippled throughout the twentieth century, especially informing the careers Nelson Mandela and Martin Luther King, Jr. To paraphrase XKCD: “Peace. It works, Brothers.”

So on this 9/11, we have a choice. We can myopically focus on the pain of the last decade and victimize ourselves all over again, or we can see the pain of these last years in light of the revelation of a century before. We can choose to entrust our salvation to a strong earthly leader and the ways of the nations, or we can choose to put our faith in the empowerment of that of God in people.

If you would like more information about the other 9/11, see the Metta Center’s Hope Or Terror?: Gandhi and the Other 9/11.

Christianity’s Pharisee Problem September 10, 2012 | 09:34 pm

Fellow Christians, we need to talk. We have a Pharisee problem, and we need to do something about it.

The problem starts in the gospels. The driving plot within the gospels—becoming more prominent as you approach the passion—is Jesus’s conflict with the religious authorities of the day. This, combined with Paul’s efforts to make sense of his people’s rejection of Jesus, results in a popular idea that Jesus was somehow against “the Jews”. There was a mass of people—”the Jews”—for whom Jesus’s message of love was incomprehensible. This mass of people were represented by the Pharisees and the Scribes, who confronted Jesus with legalisms and tricky intellectual puzzles and traps.

This way of thinking is only reinforced by the popular division of the Old Testament and the New Testament into two stories about two separate Gods. There’s the Old Testament God who is wrathful and evil and metes out merciless justice. Then there’s the New Testament God who is mercy and sparkles and lights and loves you just the way you are. There are three problems with this idea.

  1. This statement immediately implies that contemporary Judaism worships a wrathful and evil God who metes out merciless justice. Somehow, thousands of years of Judaism hasn’t ever recognized their God that way, so you’re forced to argue that contemporary and historical Judaism either A) does not know, or B) does not take seriously, their own scriptures and their own God. These are both blatantly anti-semitic claims (not to mention obviously false), and I seriously doubt most people making the Old Testament/New Testament division would care to make either of them.
  2. The New Testament God, including Jesus, has just as strong a concept of justice and is just as damning to the unjust. Jesus rejects and condemns people throughout the gospels—select targets include those who neglect the suffering, those who are evil, those who reject or ignore his message, and those who claim to follow him in word but fail to live into it in deed. Revelation is equally as unhappy with the unfaithful. And of course you see it in Paul and the other epistles.
  3. Jesus and the texts we have closest to Jesus’ own time all affirm the continuity between the Children of Israel and the followers of Jesus. If you think there is a new God in the New Testament versus the Old Testament, you are at odds with Jesus and the New Testament itself.

Beyond these issues, there’s a problem with this conception of “the Jews” because throughout all four gospels, it’s not the crowds who fail to understand and accept Jesus’s message: it’s the disciples. The crowds flock to Jesus and lay down palm leaves and cry “Hosannah!” The people that Jesus calls the most faithful are not the disciples, but the people he stumbles across along the way: the centurion, the woman at the well, the lepers who call him “King”, the bleeding woman, the woman he calls a dog. These people approach Jesus with faith and with a hope of transformation. It’s the disciples that spend all their time trying to figure Jesus out and try to get Jesus to explain himself, and thereby miss the point entirely.

The biggest issue, however, is that “the Jews” that we are reading out of scripture don’t exist. Although it is popular and common (and even arguably useful) for Christian theologians to talk about “the culture” Jesus was speaking to, the reality is that there was no homogenous mass of people that Jesus preached to. There was no “the culture”. Jesus served people, and those people were each individuals with complex histories and motivations and understandings. The more we learn about the time of Jesus, the more diversity we find, and we have even found quite a few critiques and teachings from other contemporary Judeans that sound a lot like Jesus. Thanks to our historical research, we now know that even the Scribes and the Pharisees as portrayed in the scriptures are satires and convenient fictions.

In fact, if you want to find Pharisees and Scribes and hard-hearted nationalists who reject Jesus’s message, you’re better off looking away from the 1st century Middle East and towards 21st century American Christianity.

You want Pharisees? Ask Hugh Hollowell, the Mennonite minister who runs Love Wins Ministries and serves those on the fringes of Raleigh’s social structures. Ask him about those who need to know his doctrine of the resurrection to decide if he’s a Christian. He is guiding a community that is literally feeding the hungry, befriending the lonely, and caring for the neglected sick. He does this all while proclaiming himself proudly as a follower of Christ, but people still need to know how his theology accounts for this or that passage of the Bible to know if he’s a Christian. If his theology is wrong on that point or on any other myriad number of points, then their church couldn’t possibly support him. Those are Pharisees. Every damning word Jesus said about the Pharisees and every derogatory portrayal of the Pharisees in the scriptures apply directly to them.

You want Scribes? Look to divinity schools and seminaries, where master’s students debate denominational affiliations and solve all the world’s problems over lunch tables, and where famous tenured theologians write about vulnerability and taking up the cross. I know we are the Scribes, because I was one. We aid and abet the Pharisees in their task, all the while thinking we have been gifted special and secret knowledge of God, sanctified by study and therefore able to judge our brothers and sisters.

You want hard-hearted nationalists who reject Jesus’s message? Look to every member of the Christian church who rejects Jesus’s calling in order to retain their American exceptionalism, their proud militarism, or their comfortable lifestyle. Any self-righteous indignation here should be checked, though, because that mass of people certainly includes your present author and almost certainly the reader.

Fellow Christians, we are the Pharisee problem. When John the Baptist is confronted with those who sought him out for ritual cleansing, he calls them a “brood of vipers”. He calls us a brood of vipers, because we follow any popular movement and seek out any charismatic figure who might have a quick fix for our problems. When Jesus talks about those who reject him, those who are blind, those who do not have eyes to see or ears to hear, those who have fail to have faith, then he is talking to us. He isn’t talking to some other group separated from us by time, space, or tradition. He is talking about us.

As far as I can tell, the only way to solve this Pharisee problem is for us—Christians—to change our whole way of following Jesus. And this means that we must first and foremost love people. Don’t try to love people. Don’t strive to love people. Don’t pray that some day you might be gifted with the grace enabling you to love people. Love people. Loving people may mean that things will suck sometimes. However, the few times that I have truly felt love for God, it was because I was loving people. And those people in my life who most resemble Christ are those who love others deeply and are compelled by that love. These people also have another strange commonality: they don’t have much time for abstract theology, and absolutely no time for systematic theology and creedal litmus tests. As far as I can tell, if we want to be more like Christ, then we should follow their lead, let that stuff slide, and focus our energies on more important things.

Gaelyk (Groovy/Google App Engine) Persistence in September’s GroovyMag: Announcement and Errata September 9, 2012 | 11:24 am

This month, I have an article on persistence on Google App Engine’s persistence (BigTable/DataStore), viewed through the perspective of Gaelyk. One of the big things I highlight is ways in which this NoSQL engine differs from relational databases, and what that means for structuring your data and optimizing your structures. This is a part of the conversation which is often sorely missing, so I felt the need to highlight it.

Vladimír Oraný read through it, and said he liked it quite a bit, but noticed two things that I have to correct. First, I apparently imply through my example that you need to use @Entity in order to use coercion into Google App Engine’s Entity. This isn’t true: any bean or POGO can be coerced. I knew that, but apparently conflated two steps in a way that might be confusing. Second, despite an error in the documentation implying the contrary, @Unindexed cannot be applied to a class. Instead, you need to pass that as an argument to the @Entity annotation: @Entity(unindexed=true).

Like before, you can get a free copy of this month’s GroovyMag by tweeting me for it.

JQuery PeriodicalUpdater in JSMag July 4, 2012 | 08:43 pm

The jQuery PeriodicalUpdater, which is undoubtedly my most popular open source project to date, is featured in this month’s JSMag. It’s actually a part of a two-part series, the first on jQuery PeriodicalUpdater in particular, and the second on witing jQuery plugins, using jQuery PeriodicalUpdater as an exemplar. So keep an eye out for that next month, too.

The jQuery PeriodicalUpdater is responsible for long-polling the backend from the client. When people usually write this code, it tends to be like some little kid: “Can I have it now? What about now? How about now? Now? Now? Now? Now?” This leads to exasperated servers. The PeriodicalUpdater handles this with much more grace, leading to happy servers while keeping the client up-to-date.

Like last month’s GroovyMag article, I’m offering a free copy of this month’s JSMag if you drop me a tweet asking for it. (There’s also a few more GroovyMag article codes for those tweets.)

jQuery: Timing of Selector Resolution June 17, 2012 | 07:05 pm

I was curious how eager or lazy jQuery was with its selector resolution. So when you say $(".foo"), does it walk the DOM immediately looking for things of class “foo”, or does it wait? After all, it could wait until a call comes in to modify an element before resolving the elements, which could be an optimization in some cases. This would also handle mutations to the DOM, which would be nice in certain cases (such as the bound version of PeriodicalUpdater). It could also be that that jQuery detected changes to the DoM via jQuery, and perhaps threw signals to keep things in sync.

However, it turns out that selector resolution is eager in jQuery. I checked it twice: once using a timer as a simplified version of what JQuery PeriodicalUpdater does and once using direct DOM modifications. In both cases, you see the straight eager behavior.

So there you have it: selector resolution is eager in jQuery. So don’t ask for elements until you’re sure you want them, and not until you’re sure they exist.

This Recruiter E-mail Approaches Optimally Bad June 12, 2012 | 05:05 pm

This is a headhunter e-mail I received today. I wish I could say it was out of the ordinary, but it’s only remarkable in how fully it embodies the general tone of headhunter e-mails I tend to receive.

Bottom line: Are you sick of working with people that don’t give a $*!% about their code?! Are you bored out of your skull? Are you not working up to your intellectual/creative capabilities? If any/all of this is true, we would love to speak to you. We’re not looking for 15 people; we’re looking for just one, possibly you.

Our client is on the cutting edge of cloud computing, developing software that is impacting the commoditization of cloud and influencing how big companies use and manage their clouds. This position is for a front end ‘architect/genius” developer to work on a rock star team with a focus on all NEW development, encountering challenges never before seen, and opportunities never before explored. You will work with JavaScript, CSS3 and jQuery in addition to other tools that YOU may recommend for building the best front end functionality that is possible.

Developer/coding elitists need only apply. If you are particular and passionate or know someone that is, we want to talk to you!

A few notes:

  1. Either swear or don’t. Hiding your swearing behind symbols is the worst of all possible worlds, because it says that you’re being informal enough to use crude language, but not informal enough to actually trust me to be able to read your crude language.
  2. Keep your hackneyed epithets to a minimum. Or at least pick one and commit. Rockstar? Genius? Elitist? I have to be ALL of those things?
  3. And while we’re on this point: Stop Giving Me So Many Blatant Opportunities to Think about How Great I Am. It’s a transparent sales ploy, and doesn’t give me any information about the position you’re attempting to fill.
  4. Likewise, Stop Giving Me So Many Blatant Opportunities to Think about How Horrible Everyone Else Is. Seriously? Is that the kind of person who you want to hire? You want a flaming narcissist who is going to feel perpetually underutilized and superior to the rest of the team? For real? Soft skills are valuable in software development, and the best developers I know are the ones who are also humble and engaged in communities. The brogrammer who is convinced they are smarter than everyone else is a stagnant investment for your business and a morale killer for your team.
  5. Finally, If Your Position Was That Cool, You Wouldn’t Be E-mailing Me Out of the Blue. Nobody using standard technologies is really “encountering challenges never before seen, and opportunities never before explored”. That hyperbole is just plain nonsense, and the people engaged in those kinds of projects aren’t recruiting through spammy e-mails.

Grails Database Session Plugin June 6, 2012 | 02:07 pm

I’ve done a fair bit of updating to the Grails Database Session Plugin (originally written by Burt Beckwith), and
it is now released. The plugin solves the problem of cloud services often not having sticky sessions/session affinity, so as soon as you ramp up a second Grails application, you’re losing sessions now and again.

If you want more information on this plugin, check out this month’s GroovyMag (June 2012), where I’ve got an article going over the whole thing, including the differences in implementations, a peak under the hood, and extensive details on how to use the plugin. A summary version of it is available in the README file.

BTW, if you’d like a free copy of this month’s GroovyMag, tweet me and let me know: I have a few coupons to share around.

Open Source Drop: GitHub as a Maven Repo for Gradle, a JSON parser library and client, and JavaCC Plugin for Gradle April 23, 2012 | 03:19 pm

This is an announcement of a bunch of open source code that I’ve just released.

Using GitHub as a Maven Repository for Gradle

If you’re using Gradle for your JVM builds (and you should be) and GitHub for your open source project infrastructure (and you should be), then you might be pleasantly surprised to know that you can use GitHub as a Maven repository, which means that your library can be deployed to and served from GitHub’s own cloud infrastructure.

Your clients add this line to their Gradle build scripts:

apply from:"http://smokejumperit.com/github-libs.gradle"

And at that point, they can draw from anything deployed on GitHub. Good times!

For more information (including the five lines of code necessary for you to deploy to GitHub), see the README for the RobertFischer/gradle-github-dev project.

JSON Parser Library

A long while back, I was pissed off at the available JSON parsing libraries, so I wrote my own JavaCC-drived JSON parser library. It supports a fair bit of the broken JSON that is out in the wild, and is screaming fast. For more information, see the README for the RobertFischer/json-parser project.

JSON Client for the JVM: Resty

I’ve been playing around with a bunch of different JSON clients for interacting with a REST service (GitHub’s API v3) on the JVM, and I didn’t really like any of them. All of them felt WAAAAAAAAAAAY too Java-y, and I was looking for something much simpler. RESTClient for Groovy was nice, but I had trouble debugging the errors going to and from the server. After much searching, the best I found was beders’s Resty library, but it had a problem in that it couldn’t parse JSON arrays at the top level. So I forked it.

You can check out my version of Resty, which uses my more fault-tolerant and faster JavaCC JSON parser (see above) and can parse top-level arrays. There’s also substantially improved error handling, and it’s now built using Gradle instead of Maven because XML’s pointy brackets make my eyes bleed.

JavaCC/JJTree Compiler Plugin for Gradle

Finally, I’ve updated my JavaCC/JJTree compiler plugin for Gradle. This also involved updating the compiler-base plugin. Both were overdue for an update to support Gradle 1.0, and updating them was really a joy, since it meant ripping out a lot of bad code and replacing it with newfangled Gradle API calls.

Gradle, Lift, and Google App Engine January 21, 2012 | 08:34 pm

I’m getting back into the game a little bit, and I decided to take a look at Lift for web development. After an initially promising experience, I became totally unhappy with Eclipse (it began forgetting I had Google App Engine libraries on the classpath after every clean). So I moved back to the command line. The recommendation to use Simple Build Tool or Maven for Lift put me off: SBT is pretty weak for a build tool, and Maven is…well…Maven, off to download the Internet. So I went back to Gradle.

For the record, I’m using Objectify for my Google App Engine development, because JPA gets you into that whole ugly ORM conceptual space without need: there’s no “R” in GAE, so you might as well deal with it in a more natural way.

So, given that situation, I came up with this build.gradle script. (Forgive the ugly organization, but this is actually the relevant points extracted from a multi-project build.)

buildscript {
   repositories {
      mavenCentral()
      add(new org.apache.ivy.plugins.resolver.URLResolver()) {
          name = 'GitHub'
          addArtifactPattern 'http://cloud.github.com/downloads/[organisation]/[module]/[module]-[revision].[ext]'
      }
  }
 
  dependencies {
    classpath "bmuschko:gradle-gae-plugin:$gaePluginVersion"
  }
}
 
apply plugin:'java'
 
// Buildscript dependencies and repositories
 
 
repositories {
  mavenCentral()
  mavenRepo name:'scala-releases', url:'http://scala-tools.org/repo-releases/'
  mavenRepo name:'objectify-appengine-releases', url:'http://objectify-appengine.googlecode.com/svn/maven'
  mavenRepo name:'sonatype-releases', url:'http://oss.sonatype.org/content/repositories/releases/'
  mavenRepo name:'sonatype-snapshots', url:'http://oss.sonatype.org/content/repositories/snapshots/'
 
  add(new org.apache.ivy.plugins.resolver.URLResolver()) {
      name = 'GitHub'
      addArtifactPattern 'http://cloud.github.com/downloads/[organisation]/[module]/[module]-[revision].[ext]'
  }
}
 
// Universal dependencies
 
dependencies {
  compile "org.encog:encog-core:$encogVersion",
        "com.google.guava:guava:$guavaVersion",
        "commons-lang:commons-lang:$commonsLangVersion",
        "org.apache.commons:commons-lang3:$commonsLang3Version",
        "commons-io:commons-io:$commonsIoVersion",
        "commons-collections:commons-collections:$commonsCollectionsVersion",
        "org.slf4j:slf4j-api:$slf4jVersion",
        "org.slf4j:slf4j-simple:$slf4jVersion"
 
 
  testCompile "junit:junit:4.5"
}
 
// Now the Scala stuff
apply plugin: 'scala'
 
dependencies {
  scalaTools "org.scala-lang:scala-compiler:$scalaVersion",
       "org.scala-lang:scala-library:$scalaVersion"
 
   compile "org.scala-lang:scala-library:$scalaVersion"
 
  testCompile "org.scala-tools.testing:specs:1.6.1",
    "org.scala-lang:scala-compiler:$scalaVersion"
}
 
apply plugin:'war'
 
dependencies {
  compile "net.liftweb:lift-webkit_$scalaVersion:$liftVersion",
        "net.liftweb:lift-mapper_$scalaVersion:$liftVersion",
        "net.liftweb:lift-json_$scalaVersion:$liftVersion",
        "net.liftweb:lift-util_$scalaVersion:$liftVersion",
        "net.liftweb:lift-common_$scalaVersion:$liftVersion"
 
  testCompile 'org.mortbay.jetty:jetty-util:6.1.22',
          'org.mortbay.jetty:jetty-management:6.1.22'
 
  providedCompile 'javax.servlet:servlet-api:2.5'
}
 
apply plugin: 'gae'
 
dependencies {
    compile "com.googlecode.objectify:objectify:$objectifyVersion"
    gaeSdk "com.google.appengine:appengine-java-sdk:$gaeVersion"
}
 
gae {
  downloadSdk = true
  disableUpdateCheck = true // Error with HTTPS
 
  appcfg {
    email = '[email protected]'
    logs {
      append = true
      severity = 1
      ouputFile = file('build/logs.txt')
    }
  }
}

I stash versions in the gradle.properties file, which looks like this (it’s a lot more details than you actually need):

scalaVersion = 2.9.1
liftVersion = 2.4-RC1
gaePluginVersion = 0.5.2
objectifyVersion = 4.0a2
guavaVersion = 11.0.1
commonsLang3Version = 3.1
commonsLangVersion = 2.6
commonsIoVersion = 2.1
commonsCollectionsVersion = 3.2.1
encogVersion = 3.1.0-SNAPSHOT
androidPluginVersion = 1.1.0
slf4jVersion = 1.6.4
gaeVersion = 1.6.1

If you start Lift up at this point (using gradle gaeRun), there are errors about Lift not having permission to mess with the thread pool.

Now, here’s the amazing magic trick which I found documented nowhere but discovered while digging through the Lift source code. It’s an astounding and miraculous trick which is necessary in order to get Lift to work on Google App Engine.

In the file ./src/main/resources/props/default.props, make sure to have this set:

inGAE=true

That’s it. You do that, Google App Engine works. You don’t do that, it won’t. Magic!

Back Again to There: A Nontheistic Statement of Faithiness January 20, 2012 | 10:47 am

[Editor’s Note: This is a follow-up to There and Back Again. If you haven’t read that post, start there (including the comments) and then come back.]

I finally figured out what was bothering me. While driving to the Science Online 2012 open mic night and listening to Jon Watts’ Lifted Up, I suddenly had an epiphany. Suddenly, things made sense. And it all came back to a mathematical formalism.

The formalism is the disproof by contradiction. That formalism can be colloquially expressed this way: if assuming X leads to a conclusion of not-X, then not-X is true. In this case, the specific expression is as follows: assuming rationality forms the foundation of lifestyle and morality, I have found rationality cannot form the foundation of lifestyle and morality. Therefore, rationality cannot form the foundation of lifestyle and morality.

This is a radical transformation. It is much more radical than anything else I have encountered, because it dislodges and renders impotent any question about why an action should take. This is fundamentally different than the ethical/lifestyle systems proposed to me, and it is easy to see why once you spell them out.

  • Enlightened hedonism, for instance, might claim that they are acting on this philosophy, because they are optimizing the phenomenologically self-justifying good of pleasure. Humanism or utilitarianism, insofar as they might justify themselves through enlightened hedonism, are also founded on this argument. Yet the self-justifying good of pleasure is a course that has to be maximized, and therefore there are better and worse ways of being in the world, and rationality is presumed to be critical in determining which ways are better and which ways are worse.
  • My position is actually more skeptical than the skeptics. The skeptics presume that one should live based on rational claims and oppose non-rational claims. Yet rationality itself is self-defeating, and so does not stand up to the skeptic’s own standards. (Skeptics refusing to apply their own standards to themselves is a recurring problem I have with skepticism as a community, BTW: a case in point.)
  • I don’t know much about Buddhism, but my understanding is that its core teaching is that attachment is the source of suffering, and so the goal is to not be attached to outcomes. If that’s true, than in a way, I’m more Buddhist than the Buddhists, because I’m also not attached to not being attached. (And I must admit, I do feel like I have reached a sense of Enlightenment.)

My new standpoint is the ultimate “Fuck it, let’s go bowling.” philosophy, and so I have adopted the Dude’s answer as a hyper-absurdist effort to counteract the rationalist trap. As soon as you engage a rational argument, you’re playing that ultimately self-defeating game again. Yet what is true or not true does not matter, not because of any statement about the value of truth or nihilism, but because fuck it, let’s go bowling. Why I believe something or act a certain way is not a question I have to answer, because fuck it, let’s go bowling. I’m not optimizing my happiness. I’m not striving towards an ethical life. I’m not playing into a grand narrative. I’m fuck it, let’s go bowling.

When I realized this — when I realized that my nagging issue with rationality leading to irrationality was that it proved rationality was false, and when I really realized how deep the denial of rationality went, then suddenly I was free. I saw the world differently in a moment. It was astounding.

Now, some of you may be saying, “Took you long enough.” There are a lot of people out there who have criticized me for thinking too much. I couldn’t just let stuff go, however, as long as there seemed to be compelling ethical mandates—or even the promise of compelling ethical mandates just under the next book cover. But that effort has not only yielded nothing, but actually outright self-destructed. Now I’m free of the mandate; that’s what it would take, and it finally go there: rationality is self-defeating.

(BTW, I should note that “Fuck it, let’s go bowling” is actually Walter’s line, not the Dude’s, but it so perfectly sums up the philosophy that I’m sticking to it. And besides, fuck it, let’s go bowling.)

(Also BTW, if you’d like to prove to me that rationality can form the foundation of lifestyle and morality, you’re welcome to try in the comments. Start by listing off all your presumptions. I’ll even give you Cogito, ergo sum for free, although you have to presume or argue any nouns you’d like to drive from those verbs. Also, please keep in mind that Hume pretty well destroyed inductive reasoning, so arguments from science are first going to have to undo Hume.)