One of my bad habits is ~~wasting time on~~trying out new programming languages, [every](/posts/2018/04/14/new-season) [so](/posts/2015/02/18/protected-members-in-dart-classes) [often](/posts/2010/01/21/new-blog-platform). I guess, in 2020, <a href="https://www.rust-lang.org/" target="_blank" rel="noopener">Rust</a> is the new cool thing, so I had to indulge myself. I will reserve judgement on Rust, for the time being. Suffice it to say, there are aspects of Rust that excite me, other aspects are just plain annoying. You can't deny it's versatility though, that's Rust's main selling point, if you ask me. 

As an experiment, I wrote a hello-world Web Service to be deployed as a container. Being the lazy, operations-averse engineer that I am, I use <a href="https://cloud.google.com/run" target="_blank" rel="noopener">Google Cloud Run</a> (that's a great name) which is based on <a href="https://knative.dev/" target="_blank" rel="noopener">KNative</a> (what a stupid name).

Here is the simple Web Service:

```rust
#![deny(warnings)]

use std::convert::Infallible;
use std::env;

use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};

async fn hello(_: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from(
        "hello, world",
    )))
}

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    pretty_env_logger::init();

    let make_svc = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(hello)) });

    let port = if let Ok(port_env_var) = env::var("PORT") {
        port_env_var
            .parse()
            .unwrap_or_else(|_| panic!("Invalid port env variable (PORT={})", port_env_var))
    } else {
        3000
    };

    let addr = ([0, 0, 0, 0], port).into();

    let server = Server::bind(&addr).serve(make_svc);

    println!("Listening on http://{}", addr);

    server.await?;

    Ok(())
}
```

As you can see, I decided to use the <a href="https://tokio.rs/" target="_blank" rel="noopener">Tokio</a>  runtime. I believe it will emerge as the winner of the Rust 'async wars'. The fact that it powers the wonderful <a href="https://deno.land/" target="_blank" rel="noopener">Deno</a> project is a strong reason to bet on Tokio.

On the other hand, I see no clear winner in the race for the dominant Rust Web Framework (<a href="https://actix.rs/" target="_blank" rel="noopener">Actix</a> and <a href="https://rocket.rs/" target="_blank" rel="noopener">Rocket</a> look like strong candidates) so I plan to 'wait it out'. Thus, I used the low-level <a href="https://hyper.rs/" target="_blank" rel="noopener">Hyper</a> library for this experiment.

Pay attention to one important detail: You have to listen to `0.0.0.0`, listening to `127.0.0.1` or `localhost` will not work.

Here is the `Dockerfile` I used to build the container image:

```dockerfile
FROM rust:1.46.0 as builder

ARG SERVICE_NAME=hello_service

RUN USER=root cargo new --bin /usr/src/${SERVICE_NAME}

WORKDIR /usr/src/${SERVICE_NAME}

COPY ./Cargo.toml ./Cargo.toml

RUN cargo build --release \ 
    && rm -rf src

ADD . ./

RUN rm ./target/release/deps/${SERVICE_NAME}* \
    && cargo build --release

FROM gcr.io/distroless/cc-debian10

ARG SERVICE_NAME=hello_service

COPY --from=builder /usr/src/${SERVICE_NAME}/target/release/${SERVICE_NAME} /usr/local/bin/${SERVICE_NAME}

CMD ["hello_service"]
```

Following best-practices, this Dockerfile supports a two-stage build and engages in Cargo shenanigans to enable caching a layer of dependencies. Unlike most Dockerfiles for Rust you can find online, it leverages a <a href="https://github.com/GoogleContainerTools/distroless" target="_blank" rel="noopener">Distroless</a> base image instead of Alpine Linux. The prospect of messing with <a href="https://musl.libc.org/" target="_blank" rel="noopener">musl libc</a> doesn't sound very enticing.

Sweet, let's try this locally:

```sh
sudo podman build -t hello_service -f ./Dockerfile .
sudo podman run -p 3000:3000 hello_service
```

Huh, you still use docker? Sigh:

```sh
alias docker=podman
```

Now you can browse `http://localhost:3000` to get your greeting.

Finally, let's deploy to production:

```sh
gcloud config set run/platform managed
gcloud config set builds/use_kaniko True
gcloud config set builds/kaniko_cache_ttl 24
gcloud builds submit --tag gcr.io/your-namespace/hello_service
gcloud run deploy --image gcr.io/your-namespace/hello_service
```

Please note that I enabled the <a href="https://github.com/GoogleContainerTools/kaniko" target="_blank" rel="noopener">Kaniko Cache</a> option to leverage the aforementioned cached dependencies layer to speed up the deployment.

Mission accomplished!

**Update**: 

Reduced the number of RUN commands, in the Dockerfile, to minimize the generated layers (thanks <a href="https://twitter.com/mlk0981" target="_blank" rel="noopener">@mlk0981</a>).

Also, I need to investigate how <a href="https://github.com/moby/buildkit"  target="_blank" rel="noopener">Docker BuildKit</a> can further optimize the caching of Cargo dependencies (thanks <a href="https://twitter.com/dkarlovi" target="_blank" rel="noopener">@dkarlovi</a>).

**Discussion**:

You can discuss this post on this <a href="https://twitter.com/gmosx/status/1307275121669943302" target="_blank" rel="noopener">Twitter thread</a>.

How to deploy a Rust Service to Google Cloud Run

( 🎧 Listening to <a href="https://www.youtube.com/watch?v=FGBhQbmPwH8" target="_blank" rel="noopener">Daft Punk</a> )

Again, I have an itch for writing down some thoughts. These days, I appreciate the timelessness of written essays vis-à-vis the fragility of program code. [Last time](/posts/2018/04/14/new-season), I only managed to update the blog engine, my energy was exhausted before actually delivering a single article. Oh well, I had an excuse. Life was moving fast, for better or worse, mostly better.

My professional life, as a software engineer, is moving fast as well. I switched from <a href="https://swift.org" target="_blank" rel="noopener">Swift</a> to <a href="https://golang.org" target="_blank" rel="noopener">Go</a>, then to <a href="https://rust-lang.org" target="_blank" rel="noopener">Rust</a>. I guess JavaScript (currently in the <a href="https://typescriptlang.org" target="_blank" rel="noopener">TypeScript</a> flavor) is my only real constant in programming. A quick blog engine rewrite was in store, but I have [done](/posts/2007/01/19/switching-blog-engine-again) [this](/posts/2008/10/29/the-engine-behind-this-blog) [before](/posts/2010/01/21/new-blog-platform). 😜

The new site is divided into segregated front-end and back-end components. The frontend is powered by <a href="https://reactjs.org" target="_blank" rel="noopener">React</a> and <a href="https://nextjs.org" target="_blank" rel="noopener">NextJS</a>. The backend, offering basic CMS functionality, is implemented with Rust, and just publishes a collection of json files as a REST API. Static HTML export makes everything fast and safe.

The site looks quite raw, but hopefully I will improve the aesthetics and add new sections and more content, soon. For the moment, I find the 'empty-canvas' look kind of inspiring. All the possibilities are open, don't you think?

The new logo and new top level domain is another story for another time...


One more time

So, 3 years passed. What a difference three years can make. The universe gives, the universe takes. In the end, you are a different person, yet some (bad) habits never die.

Take for example the re-engineering of this blog, every few years. Since I moved on from Dart, and I plan to post some new articles, I had an excuse to convert the engine to [Swift](https://swift.org). At least, the content was encoded in open file formats (YAML, Markdown, PNG, etc), really a bunch of files in a directory, so the conversion was trivial.

I will spare you the boring details.


New season

In general, [Dart](http://dartlang.org/) is a well designed language, but there
are some rough edges. Take for example the limited privacy options for class
members: Dart only provides for private members where the boundary of privacy
is the library.

While private members can get you a long way, often, what you are really looking
for is a protected member, i.e. a private member that is still visible to
sub-classes even if they are defined in _different_ libraries.

I guess, the canonical example is a UI framework offering e.g. a Button class.
When extending the base class to create your own FancyButton, access to
'private' implementation details is often required. Lack of protected access
forces you to expose the implementation through public members.

Thankfully, there is a simple workaround. I will demonstrate with an example,
leveraging the above-mentioned UI framework scenario. Let's start by defining
a base Button class:

```dart
library ui.button;

// 'Public' API
abstract class Button {
  factory Button({HtmlElement host}) = ButtonImpl; // Redirecting constructor
  void click();
}

// 'Protected' implementation
abstract class ButtonImpl implements Button {
  ButtonImpl({this.host});

  int state = 0; // 'protected' implementation detail.

  @override
  void click() {
    this.state = 1;
    host.classes.add('selected');
  }
}
```

In your application, name-spaced in another library, you define a custom button:

```dart
library my.app.fancy_button; // notice, this is another library

abstract class FancyButton extends Button {
  factory FancyButton({String title, HtmlElement host}) = FancyButtonImpl;
}

class FancyButtonImpl extends ButtonImpl implements FancyButton {
  String title; // voila, a protected property

  ButtonImpl({this.title, HtmlElement host}) : super(host: host);
}
```

You can use it like this:

```dart
final button = new FancyButton(title: "Cancel", host: element);

button.title // => cannot access!
button.state // => cannot access!
```

You cannot access the 'protected' members of FancyButton (or even Button's
protected members, for that matter). As an added bonus, if you would like to
side-step the protection (e.g. you are writing a unit-test and you would like
to assert some implementation details) you can just instantiate the implementation
class:

```dart
final button = new FancyButtonImpl(title: "Cancel", host: element);

expect(button.title, equals("Cancel")); // => true
```

While this workaround is relatively straightforward, I really hope Dart's
designers will introduce a `@protected` annotation in the future. An annotation
that is statically asserted (e.g. by the IDE or dart-analyzer) would be an
elegant and practical solution.


Protected members in Dart classes

I dig command line terminals, I dig retro computing, I dig cool stuff. And I
absolutely love this mind-blowing combination:

[cool-retro-term](https://github.com/Swordfish90/cool-retro-term)

![Amber flavor](amber-cool-retro-term.png)

![Green flavor](green-cool-retro-term.png)

![Scan lines](scan-lines-cool-retro-term.png)


Cool retro terminal

Apart from writing code for fun and profit, I have a thing about fonts. It's
only natural then that programming fonts have a special place in my heart.
Monospaced fonts are the de facto standard, but lately a radical idea came to my
attention: [using proportionally spaced fonts for code](http://input.fontbureau.com/info/)
and leaving the actual typesetting to the editor.

While I am still not convinced, I have to admit that the proponents of the idea,
came up with a beautiful family of programming fonts called [Input](http://input.fontbureau.com/).

![Input font gallery](input-font.png)

What can I say, it's my new favorite :)


Input font system

<p>
    So <a
        href="http://www.makeuseof.com/tag/retrovision-enjoy-oldschool-demo-scene-modern-pc-stuff-watch/">old-school</a>,
    yet so modern. I especially like the music!
</p>
<div class="video">
    <iframe title="YouTube video player" width="658" height="371" src="https://www.youtube.com/embed/WBuoyegCeXI"
        frameborder="0" allowfullscreen=""></iframe>
</div>

Luma

&rarr; [Is it 1880 or 1914?](http://continuations.com/post/92628450440/is-it-1880-or-1914)

> A lot about where we are today has similar characteristics. We have all of the
> ingredients for an information society in place: a global network that
> connects everyone, rapidly improving machine learning and automation, additive
> manufacturing and robotics (to name just a few key ingredients). We also have
> globalized many aspects of the economy with global corporations and supply
> chains.
>
> Yet again the political leadership throughout the world is still largely
> thinking in industrial terms, including emphasizing the nation state as the
> geographic organizing principle (and playing up ethnic and religious
> differences). Once again we also have large groups of people who feel pushed
> around or left behind by the emerging information economy.

I am consistently surprised that people around me don't realize what is _really
happening_ in the world today. We live in dangerous times. You better expect
(and prepare for) some disruptive changes within this decade. And I am not talking
about Valley-style, hipster disruption here...


Were are we today?

&rarr; [The need to right-size precision to save energy, bandwidth, storage, and electrical power](http://sites.ieee.org/scv-cs/files/2013/03/Right-SizingPrecision1.pdf)

The representation of real numbers within computers leaves a lot to be desired.
Every programmer is bitten at some point by floating point precision issues.
Open a JavaScript console and type 0.1 + 0.2 for the canonical example. [This
fascinating paper](http://sites.ieee.org/scv-cs/files/2013/03/Right-SizingPrecision1.pdf)
frames the problem in whole new perspective and proposes a couple of innovative
solutions. As the author says...

> Let’s make computer math much smarter than what it was in 1914!


Right-size precision

&rarr; [Ubuntu's Not Invented Here syndrome](http://www.turnkeylinux.org/blog/ubuntu-not-invented-here-syndrome)

A well-articulated analysis, the following quote particularly resonated with me:

> I don't think that Canonical is bad at what it does. It's just that they're
> rarely the best and being mediocre (or even second best) isn't good enough
> when the tournament effect is at work. The winner takes home the pot (e.g.,
> becomes the new standard) and Canonical isn't winning.

Switching to Unity and competing on so many fronts was a mistake, Canonical is
spread too thin. Still, the latest LTS release is pretty solid and pleasingly
refined. I plan to stick with Ubuntu some more, these days my mantra is to be
conservative with platform changes. If [things](https://wiki.ubuntu.com/UnityNextSpec)
don't work-out, there is always a safe [fallback](http://www.debian.org).


No Juju for you!

A new month, [a new version of Chrome is released](http://chrome.blogspot.com/2011/09/new-stable-release-of-chrome-expanding.html).
Don't get me wrong, [Web Audio](http://webaudio.github.io/web-audio-api/) is
interesting (one more nail in the coffin for Flash) and
[Native Client](https://developer.chrome.com/native-client) may be
a solution to the primary roadblock in the evolution of the Web towards an
application platform (namely JavaScript).

Still, I would prefer browser vendors to go after some low-hanging fruit first.
I mean, emerging HTML5 technologies are cool and all, but how about
concentrating on the actual HTML part first? How about implementing common
forms controls (date/time pickers, rich text editors, improved validation and
more)? How about fully implementing [CSS Paged Media](http://www.w3.org/TR/CSS2/page.html)?
How about implementing [MathML](http://www.w3.org/Math/)? How about replacing
.pdf with .html first and then focus on killing Flash?

And while we are at it, how about improving bookmark management in Chrome?
The current interface leaves a lot to be desired (i.g. multiple categorization
of bookmarks using tags and/or hierarchical folders, similar to the
categorization available in Google Docs).

In short, I would like to see more pragmatic features sooner rather than later.


The evolution of browsers

Some time ago, I wrote about [a nasty JavaScript catch](/posts/2009/08/nasty-javascript-catch.html). Well, it seems that no language is immune from nasty surprises, so here comes one for Java:

```java
BigDecimal value = new BigDecimal("0.31");
BigDecimal oldValue = new BigDecimal("0.34");
BigDecimal ratio = value.divide(oldValue);
```

throws:

```sh
java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
```

Funky, huh? Let me offer a quick fix:

```java
BigDecimal ratio = value.divide(oldValue, BigDecimal.ROUND_HALF_EVEN);
```

For some intuition (in [Khan](http://www.khanacademy.org)'s parlance), have a look [here](http://jaydeepm.wordpress.com/2009/06/04/bigdecimal-and-non-terminating-decimal-expansion-error/).


Nasty Java catch

<p>
    This came to my attention and I had to share it:
</p>
<div class="video">
    <iframe title="YouTube video player" width="658" height="371" src="https://www.youtube.com/embed/VRdZcA41EJc"
        frameborder="0" allowfullscreen=""></iframe>
</div>

Ultra geeky holiday e-Card

A few days ago, I needed to center a mini site horizontally _and_ vertically
(don't you just love client requests?). It 's easy to tackle the horizontal
axis using CSS:

```html
<style>
    .hcenter {
        margin: auto;
        width: 320px;
        height: 240px;
    }
</style>
<div class="hcenter">Horizontally centered text</div>
```

On the contrary, I thought that CSS can't handle vertical centering (at least
in a cross-browser compatible way) and a quick Google session ended fruitless
as well. Instead, I wrote a small script to programmatically center the div
inside the window. It took a couple of revisions to support resizing, eliminate
flickering, ensure cross-browser compatibility, etc. but eventually I got
it right.

Today though, I re-discovered an old trick:

```html
<style>
    .center {
        position: absolute;
        width: 320px;
        height: 240px;
        top: 50%;
        left: 50%;
        margin-top: -120px;
        margin-left: -160px;
    }
</style>
<div class="center">Horizontal and vertical centered text is possible.</div>
```

Duh!

**Update**, 24 Oct 2010: Oh, there is a better way:

```css
    line-height: ${height}px;
```

where \${height} is equal to the height of the container.

**Update**, 31 Aug 2014: [HTML5 rocks](http://www.html5rocks.com)! You can do this easily now,
using [CSS flexbox layout](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Flexible_boxes).


Center a div horizontally and vertically using CSS

A few days ago, [Joyent](http://www.joyent.com) unveiled the public beta of their
NodeJS-based platform-as-a-service contender. Well, this service rocks! From the
great [no.de](http://no.de) domain name to the RESTful procurement/management
API and the git-powered deployment, everything radiates coolness.

Even though I posted my hearts to the API end-point (/♥ !!), I haven't
received any coupons in return. So there is no review for you. However,
the elegant simplicity of the API (combined with the clean-slate design of the
underlying NodeJS infrastructure) lights my geeky heart (pun intended).

[I am not a NodeJS fan-boy](/posts/2010/06/23/ringojs-vs-nodejs). These days
I am evaluating Java/GWT (so far I am positively surprised but I 'll reserve my
final judgement for a future post). So, you understand, like everyone who feels
overwhelmed by the complexity of the Java ecosystem, I can appreciate a
refreshingly simple alternative.


I ♥ no.de

> We are what we repeatedly do.
> Excellence, then, is not an act, but a habit.

[Aristotle](http://en.wikipedia.org/wiki/Aristotle), 384-322 BC


We are what we repeatedly do

Last year, Google released the [Closure suite of tools](https://developers.google.com/closure)
for JavaScript development. It seemed too good to be true. A robust client-side
JavaScript toolkit and UI framework was just what I missed in my stack.

I quickly downloaded the distribution and, like the rest of the world, was
immediately disappointed: The source looked like Java, with long name spaces
and getters/setters everywhere. The compiler looked interesting but difficult
to setup and integrate in the build process. The templating engine looked ugly
and required a compile step. I switched back to jQuery faster than you can
say 'crap'.

The problem is I wasn't fond of jQuery either. It 's great for improving the
interactivity of a page or adding special effects but leaves a lot to be
desired when you are building a business-oriented Web application. As I am
working on a series of Web applications for deployment through Google Apps
Marketplace I decided to give Closure a second chance.

I followed a couple of online tutorials, browsed through the online API
reference and the thoroughly commented source code and experimented with some
demo apps. Eventually, the concepts of Closure started to sink in. But still,
I had like hundreds of questions.

That's when I decided to buy the
[Closure, the definitive guide](http://www.amazon.com/gp/redirect.html?ie=UTF8&location=http%3A%2F%2Fwww.amazon.com%2Fs%3Fie%3DUTF8%26x%3D0%26ref_%3Dnb%5Fsb%5Fss%5Fi%5F0%5F10%26fsc%3D14%26ih%3D12%5F1%5F0%5F1%5F0%5F1%5F0%5F1%5F0%5F1.70%5F207%26y%3D0%26field-keywords%3Dclosure%2520the%2520definitive%2520guide%26url%3Dsearch-alias%253Daps%26sprefix%3DClosure%2520th&tag=httpwwwreizuc-20&linkCode=ur2&camp=1789&creative=390957)
book, available as a Rough Cut from O'Reilly. What a great book! The
[author](http://blog.bolinfest.com/) painstakingly discuses the design rationale
behind the Closure tools and exposes the benefits of the suite. The Closure
library is genetically engineered to work with the Closure compiler and the
Google developers behind it are really obsessed with performance, memory
consuption, compatibility and code safety/debugability. The whole system is
optimized for bigger development teams, not quick Web page hacks.

Among other things, I learned that:

-   the powerful type system eliminates a large class of bugs
-   the compiler eliminates the long name spaces (and the corresponding run-time look ups)
-   getters/setters actually lead to better compression
-   you can split the client side code in multiple, independently loaded modules
-   the pseudoclassical pattern used for OOP is actually better than the functional pattern (when combined with the Closure compiler)
-   you can easily extend the Compiler with extra features...

...and so much more. I don't want to spoil your fun, just grab this great book.
It's the only way to really get into Closure. Heck, I would recommend this book
even if you are not interested in Closure, it will make you a better
JavaScript programmer.

Don't get me wrong, no tool is really perfect. Closure still has some issues:
no CommonJS compatibility (but then again, CommonJS seems kind of dead these
days), limited support from Google (they seem to be pushing GWT instead) and
a shallow community around the project. Still, Closure suits my needs better
than other solutions.

The verdict? Buy Bolin's [excellent book](http://www.amazon.com/gp/redirect.html?ie=UTF8&location=http%3A%2F%2Fwww.amazon.com%2Fs%3Fie%3DUTF8%26x%3D0%26ref_%3Dnb%5Fsb%5Fss%5Fi%5F0%5F10%26fsc%3D14%26ih%3D12%5F1%5F0%5F1%5F0%5F1%5F0%5F1%5F0%5F1.70%5F207%26y%3D0%26field-keywords%3Dclosure%2520the%2520definitive%2520guide%26url%3Dsearch-alias%253Daps%26sprefix%3DClosure%2520th&tag=httpwwwreizuc-20&linkCode=ur2&camp=1789&creative=390957)
and give Closure a try!


Closure: The world's most misunderstood JavaScript library

Unless you 've been living in a cave for the last year, you know that server
side (better: 'general purpose') JavaScript is all the rage. Everything started
with CommonJS: the emerging standard spawned an ecosystem of compatible
implementations competing against each other while advancing the JavaScript
state of the art.

Then, NodeJS happened: An async only JavaScript platform, powered by V8, not
really interested in CommonJS conformance. RY (the new DHH) managed to grab the
attention of the developer community with cool marketing, leaving other
implementations in the shadows. One such great implementation that deserves more
attention is RingoJS.

Some time ago I switched from Narwhal to Ringo and never looked back. I
strongly believe that Ringo is the preeminent CommonJS implementation.
Here is why:

-   Ringo is quite possibly the most conformant CommonJS implementation, certainly
    more conformant than Narwhal and Node.
-   Ringo is _fast_. If you tried Narwhal/Rhino and found start up times lacking
    or module reloading unacceptably slow check out Ringo! You will be pleasantly
    surprised. And while v8 may be faster than Rhino, the JVM is still quite
    optimized for server side environments. (And btw, in a modern Web application,
    time spent running the server side script is a negligible percentage of the
    total request/response cycle. You should probably work on optimizing network
    issues, database interactions, client side rendering, etc).
-   Ringo is mature, stable and crash free. Ringo is the evolution of Helma, one
    of the first server side JavaScript platforms (more than 10 years in
    development). It's also based on the mature Java platform. Contrast this to
    reports of NodeJS crashes.
-   Access to the gazillion of Java libraries. There is no merit in reinventing
    the wheel, just reuse code from the Java ecosystem. The integration between
    Java and JavaScript is seamless.
-   Windows compatibility. OK, Windows sucks, but still, a lot of engineers use
    Windows as a development platform. Ringo apps work on Windows out of the box.
-   Support for synchronous and asynchronous APIs. Use what's best for your application.
-   Thanks to AppengineJS you can run your Ringo applications on Google's
    scalable infrastructure.
-   The lead developer is extremely talented and friendly.
-   Stop drinking the Kool-Aid! Engineer your application on top of a mature,
    conformant and compatible platform: RingoJS.

_Update_: Removed a controversial link.


RingoJS vs NodeJS

I 'm not in the mood for a long post, so here are some random thoughts in aggregate form:

## f8

The new Facebook Social Plugins are FriendConnect done right. FriendConnect has
so much potential yet the current implementation leaves a lot to be desired
(to say the least). Moreover, the [Graph API](https://developers.facebook.com/docs/graph-api)
is a bold step forward towards the machine readable Web (Web 3.0 / Semantic Web
if you will). The 'Like' button is an obvious (yet powerful) idea that Google
should have implemented a long time ago.

## π is wrong

I always thought that 'π' should be the number known as '2π'. Then 'π' would be
the perimeter of the unit circle, angle measurements would be more intuitive
(90 degrees == π/4, 180 degrees == π/2, 360 degrees = π, ie a full 'cycle' is π
radians) and a lot of formulas would be simplified:

```
p = πr, i.e. scale the unit perimeter by the radius,
sin(x+π) = sin(x), i.e. the period of the trigonometric functions is π,
```

etc. At the moment π is the sum of the angles in a triangle and the perimeter
of a circle of with a diameter equal to 1 (doesn't this look awkward to you?).
Read [π is wrong](http://www.math.utah.edu/~palais/pi.pdf) for a better treatment of the argument.

## iPhoneOS TOS

The latest iPhoneOS TOS made a lot of developers angry. I don't agree. One of
the problems in our profession is what I call a Babel situation: So many
different languages and platforms hinder cooperation. Finding and integrating
engineers into a software development team is a pain. Thus, having a single
platform (iPhoneOS), a single system language (Objective C) and a single
scripting/application language (JavaScript) is refreshing.


Miscellanea

> The Web is the new UNIX,
> UNIX is the new BIOS.

[George Moschovitis](http://www.gmosx.com), 2010


The Web is the new UNIX

Old time readers of my blog know that I regularly change the platform that I use.
Lately, I was using Google's [Blogger](http://www.blogger.com/), but I wasn't
happy with the layout. Before that, I used a lovely, custom-made,
[Ruby-based CMS](#). But since I am fed-up with Ruby (after 8 years, no less)
it was difficult to maintain.

Therefore, I decided to utilise my [AppengineJS](https://github.com/gmosx/appengine)
and [Nitro](https://github.com/gmosx/nitro) open source projects to create a new
platform for my blog. This new version is implemented in JavaScript, the language
of the Web, and one of the languages I dig these days (the other being
[Haskell](http://www.haskell.org)). Even though I am relatively pleased with the
result (and the clean code behind it), there is a lot of work to be done, when
I find the time.

In the meantime, please subscribe to my feed and check this blog often for
interesting content. Oh, and bug reports are always welcome ;-)

Update: This blog is not based on the [blog-gae example](https://github.com/gmosx/appengine-blog-example)
source code. In fact, the blog-gae example is outdated and does not reflect the
latest improvements in Nitro and AppengineJS. Perhaps, I will release the mini
CMS behind this blog as an example if there is sufficient demand...


New blog platform

I had the pleasure of attending the first [Open Coffee](http://www.opencoffee.gr/)
meeting, two years ago. From the humble beginning (10 geeks in a small cafe) the
project went from strength to strength. Typically, around 300 people participate
in the monthly event where aspiring entrepreneurs present their ideas.

I always thought that Open Coffee was just one part of the equation: surely,
networking opportunities are important for bootstrapping an ecosystem of
entrepreneurs. But a great idea doesn't guarantee a successful business. Neither
does technical savvy.

A business needs funding, legal consulting, prudent accounting and strong
management to flourish. [The OpenFund](http://theopenfund.com) is Open Coffee's
long awaited take on this problem. Borrowing the concept of [YCombinator](http://ycombinator.com)
and similar funds, OpenFund will hopefully spark a number of successful start-ups in
the region.

The management team kindly accepted me as an adviser to the fund. I am fond of
the idea of helping young people avoid the many mistakes I made in the last decade.


The Open Fund

JavaScript definitely has some rough edges. Consider this:

```js
parseInt("07") // => 7
parseInt("08") // => NaN
```

This is a great reason for a 20 minutes long debugging session :(


Nasty JavaScript catch

> The secret of happiness is simple: find out what you truly love to do and
> then direct all of your energy towards doing it. Once you do this, abundance
> flows into your life and all your desires are filled with ease and grace.

[The Monk Who Sold His Ferrari](http://www.amazon.com/gp/product/0062515675?ie=UTF8&tag=httpwwwreizuc-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0062515675)


The secret of happiness

Merry Christmas

> Simple is efficient,
> efficient is beautiful.

[George Moschovitis](http://www.gmosx.com), 2007


Simple

A few of my friends where curious about the engine that powers this blog, so I
decided to shed some light on this issue by writing this post.

As already revealed in the Nitro mailing list, this site runs on the experimental
web application framework I am playing with for quite some time. Even though I
still call it Nitro, this is really a quite different beast.

It incorporates the results of my research on web application development over
the last 3 years. A few hard lessons where learned during the life cycle of the
original version so I tried to fix my mistakes this time.

The original plan was to implement the new version using JavaScript or Haskell.
On the way I decided it was more practical to concentrate on the high level
design first and validate it with a Ruby prototype. When I am happy with the
new API, and the new framework is successfully used on a few personal projects
I may convert the minimal Ruby code base to JavaScript. A release of mod_v8
and/or mod_tracemonkey will most certainly be a great motivation ;-)


The engine behind this blog

> The truth points to itself...

[Kosh Naranek](http://en.wikipedia.org/wiki/Kosh_Naranek), Vorlon ambassador


Wise words

Today is a special day. I would like to officially launch 4 long term projects.
You will only get the names, more details will emerge when it's appropriate.

1. Reizu
2. Normal
3. Unjou
4. Nafela


07-07-07

I read a lot of sites every day. Switching from site to site is time consuming
and distracting. Of course I could use an RSS aggregator but I prefer a web
solution. I know, I know there is Google Reader too, but for some reason, I am
not 100% happy with its interface. I would like to organize feeds in 'planets'
and further organize these planets in broad categories.

Using my ultra cool Nitro Web Application Framework it was easy to quickly
hack up a nice web application that suits my browsing/reading
style. It 's called Phidz (<www.phidz.com>, feeds.com was obviously not available)
and I would like to invite you to this comprehensive collection of feeds for
interesting topics. I am adding new feeds (and some new categories) daily, so
check back often.

I hope you will like the clean user interface that promotes the content.
Hopefully, you will even suggest some more feeds (just add a comment after this
blog entry). Whatever you do, always remember to have fun and enjoy life!


The best feeds for the best topics

Every 6 months I have the pleasure to install a new version of Ubuntu. Some days
ago, I installed the latest version, 7.04 aka Feisty Fawn. As you probably
already know, Feisty is the best release yet. The installation went smoothly,
hardware detection (including WiFi) was top notch and everything feels more
polished than ever.

I am using Gnome based Linux systems for the best part of the last 6 years.
Since November, I am using Linux exclusively on my laptop (I have formatted the
Windows partition). In general I am very happy, but lately I get the feeling
that Ubuntu/Gnome are not progressing that fast any more. For example, I was
disappointed that Compiz/Beryl is not included by default. Granted, it is now
easier than ever to enable 3d effects and everything works smoothly, but after
20 minutes or so my laptop hangs :(


Ubuntu Feisty Fawn

What started as a simple cleanup, resulted in a total reimplementation of
Nitro's internals. Over the last two weeks I have reorganized the directory
structure, removed a lot of cruft that has accumulated over the years and
implemented almost everything from scratch. The new code is extremely clean,
elegant, readable and understandable (though I am saying this myself). A lot of
infrequently used functionality is removed, but what stays is robust and
polished. The code is so much more flexible.

This new version represents my sixth generation web framework (in 7 years).
Every new version is becoming simpler and yet more powerful. The benefit of
hindsight and the experience gained from extensive practical usage (not to
mention the comments and suggestions of users) leads to a better software
architecture.

If you are a [Nitro](https://rubygems.org/gems/nitro) (or
[Og](https://rubygems.org/gems/og)) user, I suggest that you have a look at the
repository version. Even though the repository version is unstable these days,
as I frequently push new stuff, now is a great chance to review my changes and
potentially propose better alternatives or identify problems. In a sense, it
is your chance to make sure that Nitro will become your framework.


Nitro reloaded

[Mark](http://www.markpapadakis.com), a good friend, passed the 'five things
button' to me. So, I guess, I have to disclose 5 weird facts about me:

1. I wrote my first computer program without actually having a computer. It was
   an adventure game called "Into the Lair" (or something like that, I don't
   remember exactly) for [Spectrum ZX 48](http://en.wikipedia.org/wiki/ZX_Spectrum).
   I wrote it on a piece of paper and actually typed the code while visiting a friend
   (the lucky bastard was a happy owner of this legendary micro).

1. The most innovative hack I 've seen is the implementation of
   [Sync Scrolling](http://www.atari-forum.com/viewtopic.php?f=1&t=4357) (aka
   Hardware Scrolling) on the Atari ST as introduced by legendary coder Nick of
   Carebears. Nick was able to emulate the missing Video Memory Low Byte by
   playing with scan-line lenghts in the top border. After all these years I still
   find this technique amazing.

1. I can be a very difficult person, one can get me angry very easily. However,
   I also tend to calm down quickly.

1. I often wake up 5 minutes (or so) before the time I actually intend to wake
   up. It's like having an internal alarm clock, hardwired to my brain.

1. I never understood why 'men prefer blondes'. I always found dark haired women
   sexier.

I guess, I have to pass the button to more people. Well, I would like to
learn more about [Stefanos](http://www.anabubula.com) and [Kostas](http://nasis.com).


Five things you didn't know about me

I started working on [Nitro](https://rubygems.org/gems/nitro) a long time ago.
Browsing the source code I realized that over the years a lot of unused
functionality has accumulated. Some core components of Nitro are more complex
than they should be. In hindsight, I can implement many features more elegantly,
efficient and user-friendly. And, in the process, make the code more readable.

It is very fortunate that these days I can devote some time to improve the
code-base. If you fell adventurous enough, pull the latest changes from the
repo version and have a look at my work in progress. And while you are at it,
send your suggestions to the mailing list or even better do submit some cleanup
patches. I can use all the help I can get.

PS: You can expect some great new features too: RESTful controllers, implicit
support for Atom publishing, Sitemaps and more...


Simplifying Nitro

[JQuery](http://www.jquery.com) is my favourite javascript library. It is lean
and mean, pragmatic and generally a joy to use. The nicely organized web site
and tons of easy to follow tutorials help as well. Moreover, JQuery fits nicely
in a Nitro web application. I use a simple Nitro Element to integrate JQuery
code in my templates:

```ruby
class JQuery
    def render
        %~
        <script type="text/javascript">
            $(function() {
                #{content}
            });
        </script>
        ~
    end
end
```

And this is used like this:

```ruby
<JQuery>
    $('#clickme').click(function(e) {
        $(this).toggle();
    })
</JQuery>

...

<div id="clickme">Hello</div>
```

Simple and effective, don't you think?


Using JQuery with Nitro

Today I discovered that Wii allows you to send and receive emails from the
message center. My Wii Number is 5792180862955168 so if you want to send me a
wiimail, use the following address: 5792180862955168@wii.com. From what I hear
Miis from other Wiis can mingle on my Wii. I am not sure if I need to do
something to enable this feature. If anyone knows better please advise.

I would love to see some new Miis in my plaza ;-)


My Wii number

Yesterday, I was preparing to leave my apartment and go to my parents house. I
closed all the lights and while I was opening the door, I noticed my Wii glowing
blue in the dark. 'Strange', I said while opening my TV. Some seconds later I
was reading Nintendo's note in the Message Center. [The Wii News Channel was
ready for download](http://gizmodo.com/231654/first-nintendo-wii-news-channel-tour-and-screenshots).
I was really curious so I closed the door and pressed the download button (oh,
I love using the Wiimote as a pointer). A minute or so later, I was browsing
the new interface.

It is just great! The ability to 'grab' the globe with the Wiimote and zoom
into each country and see what's happening is just great. The news items
themselves are quite lengthy and informative as well. They are provided by
AP. I especially like the Slide-show feature: you can just lay on your sofa
and watch random news on a rotating earth.

I really think that it is a shame that Wii (and DS) is a product of Nintendo.
This lovely piece of hardware has so many possibilities, and I am not sure
Nintendo is the right 'parent' for such a prodigy. More about this in a future
post.


Wii News Channel

The repository version of Nitro now includes an improved implementation of the
`encode_url` operator (a.k.a. the `R` operator). The `R` operator now provides a
couple of shortcuts for some common cases.

You can use the first shortcut if you follow Nitro's normalized controller
convention (NCC). What is a normalized controller I hear you asking? Hmm,
just a buzzword for a simple convention to name your controllers. An example
will make this clear: Let's say you have an Entity (model) called `Article`.
Then, following the NCC, you should use a single controller to handle (control)
this class, and name this controller simply `Article::Controller`. Using this
convention, Nitro can automatically deduct the controller used to control a
given class. Let's see how the R operator uses this convention:


Improved Nitro encode_url operator

Quite often my [Og](https://rubygems.org/gems/og) managed objects (Entities)
include an attribute that takes enumerated values. I use the following code
snippet to augment [Nitro](https://rubygems.org/gems/nitro)'s form generation
helper to render a usable control.

```ruby
TYPE_VALUES = Dictionary[
    TEXT = 0, 'Article',
    IMAGE = 1, 'Image',
    VIDEO = 2, 'Video'
]

attr_accessor :type, Fixnum, :control => :options, :options_data => TYPE_VALUES
```

This code uses the `Dictionary` class from the [Facets](https://rubygems.org/gems/facets)
library. I hope you will find this useful as well ;-)


Ruby idiom to fill enumerated Og managed attributes

Some time ago, following a [friend](http://karagos.com/)'s advice I decided to
test-drive MediaTemple's Grid-Server offering (well, I admit, I was influenced
by the strong marketing buzz around this hosting solution). I quickly realized
that it was nothing more than a normal virtual server without root access.
Disappointed, I turned my attention to other solutions (eventually I settled
down with Amazon EC2, and I am extremely happy, more about this marvelous
service in another post).

During my short experimentation with the Grid-Server I installed Wordpress. When
I saw the administration interface it was love at first sight. This is the most
user friendly and intuitive application I have ever used (well, if you don't
consider GMail, that is ;-)). I immediately moved my Blog from the custom coded
Flare Blog system (based on Nitro) to this great CMS software.

I was so happy with my new Blog, that I forgot that I was paying 20\$/mo for a
'dedicated' server used almost exclusively to host a Wordpress blog. Nah, time
to switch to one of these public Blog services, I said to myself. Wordpress.com
was the obvious candidate. However, after a quick investigation I came to the
conclusion that the free version is kind of restricting (no HTML edit?).

I decided to try Blogger.com. Even though it is considerably less intuitive than
Wordpress (and certainly not as elegant), it allows me to use my domain name,
create multiple blogs attached to the same Google account and I can edit the
HTML template. I decided to accept it's shortcomings and give it a try. So I
created two blogs, the one you are reading at the moment and a new greek version.
This blog will contain mainly technical (geeky) posts, the greek one will
contain general, life-related ramblings. Let's see how this will work out...


Switching blog engine (again!)

The last few days were full of activity, but as always I managed to find some
time to pursuit my more geeky interests:

1. I am trying to learn [Haskell](http://www.haskell.org). The functional
   programming style is well suited for building scalable distributed applications.
   Moreover, Haskell is so different than other languages that it makes me feel
   excited. Haven't had such fun since I first experimented with Ruby.

1. At last, I resolved my ADSL problems and I have a proper Internet connection
   at home. If you are a Greek reader here is my current opinion on
   [Tellas](http://www.tellas.gr): The call center is difficult to reach, but the
   support team is knowledgeable and the actual Internet Connection seems quite
   speedy. Not many years ago [NTUA](http://www.ntua.gr) was served by a single 2
   Mbps connection, and now I have a 4Mbps connection in my bed room!

1. I downloaded the Wii Internet Channel. This works great, easily surpassing
   my expectations. For example cull.gr works like a charm. Every day, as I get
   more comfortable with the Wii interface I more and more admire the excellent
   work Nintendo's engineers have done on this system. Wii can really make the
   world of Games and Internet accessible to non-technical people. Hey, even my
   mother tried (and liked!!) Wii Tennis.

1. I prepared a new homepage, I am sure you can guess my inspiration.

I am considering a number of web site ideas for the Greek market while actively
working on infrastructure code and processes. I am also looking for potential
investors, so if you feel like it you can contact me.


Update

Amazon recently added a nice feature to its Associates Program:
[Astore](http://astore.amazon.com/). In essence, this allows you to build a
customized store and sell items from Amazon's vast product catalog. As I plan
to review or reference a lot of books and other products in this Blog, I thought
it was a good idea to prepare a nice little collection of carefully selected
books, DVD's, Music, Games, etc.

Well, welcome to '[Selected by Gmosx](http://astore.amazon.com/gmosx-20)' then!
If you are interested in programming, business, design, computers, games, music,
movies, science and more you will find something you like here. Only the
absolutely best products will be featured in this shop. Check back often to view
the latest additions. And remember, when ordering from my store you are
supporting my continuous work on numerous free projects.


Selected by Gmosx

It is amazing to see one person (or more accurately a small group of people,
led by a single person) turn up the fortunes of a company. This is what I think
Jonathan Swartz has accomplished. And quite spectacularly so!

First there was OpenSolaris, then OpenSparc the first open source
processor (!!!!!!!!), Cool threads/Niagara, the ultra cool new AMD powered
servers, Project BlackBox (incredible idea), Sun Grid, hiring the
JRuby programmers...

And now, Java released under the GPL license. Nothing short of stunning!

Sun is a company to watch!


## Introduction

Ruby is a wonderful object oriented language featuring a well designed syntax and advanced constructs to bring the joy back to programming. Creating the object model to describe your problem domain is easy, but making this model persistent is another story: you have to deal with relational databases and the SQL language.

RDBMS systems are a proven and robust technology for storing and querying data, but after experiencing the wonders of Ruby, it is hard not to wish for a better way to integrate the OOP and Relational paradigms.

Og makes your dream come true! Og stands for ObjectGraph and provides a transparent way to make your objects persistent while leveraging the full querying power of an RDBMS system. In fact, Og is designed to use an RDBMS system like MySQL or PostgreSQL to implement the actual data store where the objects are serialized.

But, enough with the techno-babble, lets walk through a simple example to give you a better idea of what Og can do.

## Installing Og

The best way to install Og is through RubyGems. For example:

```sh
gem install og
```

In order to use Og with a specific RDBMS, you have to install the corresponding Ruby binding. A list of supported RDBMSs and information about the Ruby bindings can be found in the README file.

Alternatively, you can install a .tar.gz or .zip distribution. You can find these at the following URL:

www.rubyforge.com/projects/nitro

## A Basic Blog Model

Blogs are in vogue. It seems that almost everyone is running a blog, and many try to code one from scratch. Well review the steps necessary to generate the persistence model for a blog application using Og.

Lets start by designing the objects well use. Our simple Blog will use these three objects:

```ruby
class Category
  attr_accessor :name
end

class Post
  attr_accessor :title
  attr_accessor :body
  attr_accessor :author
end

class Comment
  attr_accessor :title
  attr_accessor :body
  attr_accessor :author
end
```

As you can see, this is pure Ruby code. One of the features of Ruby is dynamic typing. When defining the attributes of our objects, we dont declare the actual type. However, in order to persist the model in SQL, we need to provide some hints to Og.

Og provides a replacement to the attr* family of methods to facilitate attaching metadata to the objects attributes. An attribute that contains metadata is called a property. For each attr* method, there is a corresponding prop\* method. That is,

```ruby
attr          => prop
attr_accessor => prop_accessor
attr_reader   => prop_reader
attr_writer   => prop_writer
```

Here are the class definitions using the property mechanism:

```ruby
require 'og'

class Category
  prop_accessor :name, String
end

class Post
  prop_accessor :title, String
  prop_accessor :body, String
  prop_accessor :author, String
  prop_accessor :create_time, Time
  prop_accessor :hits, Fixnum
end

class Comment
  prop_accessor :title, String
  prop_accessor :body, String
  prop_accessor :author, String
  prop_accessor :create_time, Time
end
```

Notice that the prop_accessor works similar to Rubys attr_accessor. Here are some examples:

```ruby
prop :title, true, String
prop_reader :title, :body, :author, String
```

To make the definitions look even cleaner, Og provides the property alias:

```ruby
class Category
  property :name, String
end

class Post
  property :title, String
  property :body, String
  property :author, String
  property :create_time, Time
  property :hits, Fixnum
end

class Comment
  property :title, String
  property :body, String
  property :author, String
  property :create_time, Time
end
```

This is most of the information that Og needs to manage these objects. Before we continue, we need to setup the actual RDBMS data store used by Og. Currently, Og has built-in adapters for PostgreSQL, MySQL, SQLite3, and Oracle. For this example, well use the PostgreSQL adapter, so add this code after the class definitions.

```ruby
db = Og::Database.new(
  :database => 'test',
  :adapter  => 'psql',
  :user     => 'postgres',
  :password => 'navelrulez'
)
```

Now you are ready to save your first object into Postgres. Add the following code:

```ruby
# create the object
p = Post.new
p.title = 'Hello'
p.body = 'World'
p.author = 'tml'

# save the object in the database
p.save
```

Thats it! Og works behind the scenes doing all the work for you. This simple command, p.save, does the following:

-   Creates the database test if it doesn't exist.
-   Creates a table to store Post objects if it doesn't exist. The tables columns map to the object properties.
-   Creates SQL indices.
-   Creates any needed sequences.
-   Serializes the object into the table.

Issue the following SQL to see the result:

```sql
SELECT * FROM og_post
```

This is nice, but where does the `#save` method come from? Og uses Ruby's advanced introspection features to automatically 'enchant' class that define properties. An enchanted class provides several methods that will be discussed in the following text. These enchanted classes are called managed classes.

Before going on, lets look at another Og macro that eases object creation:

```ruby
p = Post.create
```

Create automatically calls the save method. Here is another way to save the object:

```ruby
db << p
```

or

```ruby
db.save(p)
```

Lets create a Category object.

```ruby
cat = Category.new
cat.name = 'Programming'
cat.save
```

If you investigate the generated `og_category` table, you will see an `oid` column which serves as the primary key. This column is added automatically by Og. You can use the `oid` values to lookup objects:

```ruby
cat = Category[1] # loads the category object with oid = 1
```

or

```ruby
cat = db.load(1, Category)
```

As a convenience, Og allows you to lookup the category using the special property `name`:

```ruby
cat = Category['Programming']
```

You can lookup objects by name only if the name property is defined.

If you want to view Og's SQL, you can enable debug mode by setting this global debug (DBG) variable:

```ruby
$DBG = true
```

## Customizing the Schema and Defining Relations

Og makes our blog model persistent through a simple interface. The next step is to refine the schema and define relations between the objects:

```ruby
class Post; end
class Comment; end

class Category
    property :name, String

    many_to_many :posts, Post

    def initialize(title = nil)
        @title = title
    end
end

class Post
    property :title, String, :sql => 'VARCHAR2(32) NOT NULL'
    property :body, String
    property :author, String
    property :create_time, Time
    property :hits, Fixnum, :sql_index => true

    has_many :comments, Comment

    def initialize(title = nil, body = nil, author = nil)
        @title, @body, @author = title, body, author
        @create_time = Time.now
        @hits = 0
    end
end

class Comment
    property :title, String, :sql => 'VARCHAR2(32) NOT NULL'
    property :body, String
    property :author, String
    property :create_time, Time

    belongs_to :post, Post

    def initialize(title = nil, body = nil, author = nil)
        @title, @body, @author = title, body, author
        @create_time = Time.now
    end
end
```

Observe the :sql property option is used to refine the generated column type for the title property of Post, and how the :sql_index option is used to add an index to the generated table.

Notice that the initialize methods provide default values to all parameters. This is required for all managed objects.

Observe the many_to_many, has_many, and belongs_to macros. Og uses these macros to define the relations between standard Objects. In essence, Og defines a domain specific mini language. The following kinds of relations are supported:

-   has_one: has one object of the given type.
-   has_many: has many objects of the given type.
-   belongs_to: belongs_to an object of the given type.
-   many_to_many: defines a many-to-many relation. The corresponding rows in the database are linked through a join table.
-   refers_to: refers to another object.

These macros generate the constructs needed to efficiently implement the corresponding relations. For example, the belongs_to macro generates the property that links to the parent. The many_to_many relation generates the join table that links the participating classes.

Note that we have to use forward definitions of Post and Comment to satisfy Rubys parser. Workarounds will be provided in a future version.

After defining these relations, using and querying the object model is easy:

```ruby
cat = Category.create('Programming')

cat.add_post { |p|
    p.title = 'Title'
    p.body = 'Body'
}

cat.add_post { |p|
    p.title = 'Another'
    p.body = 'Hello'
}

cat.posts
=> [Post(Title), Post(Another)]

cat.posts[0].title
=> Title

cat.posts.size
=> 2

p = Post[1]
p.title
=> Title

p.categories[0].title
=> 'Programming'

c = Comment.new('hello', 'world', 'tml')
c.post = p
c.save

p.comments.size
=> 1

p.add_comment { |c|
    c.title = 'Hi there'
}

p.comments[1].title
=> 'Hi there'

com = Comment.new('Hi there')
p.add_comment(com)
```

All the methods used in the above examples are generated automatically. These methods transparently modify the underlying SQL schema using efficient queries.

Og provides full access to all features of the underlying RDBMS. Look at the following:

```ruby
post = Post.select("title='Title' and body='Body'")
post.size
=> 1
post.hits
=> 0
```

Updating existing objects is easy too:

```ruby
p = Post[1]
p.title = 'Changed'
p.save

p = Post[1]
p.title
=> 'Changed'
```

You can also update specific properties, for example:

```ruby
p = Post[1]
p.update_properties "body='Hello world'"

p = Post[1]
p.body
=> 'Hello world'
```

If you don't like a particular comment, you can easily delete it by doing the following:

```ruby
Comment.delete(comment)
```

or

```ruby
comment.delete!
```

or even

```ruby
db.delete(comment)
```

To delete all comments for a posting, enter the following:

```ruby
p.delete_all_comments
```

When deleting an object that participates in relations, Og tries to delete all
objects that belong to this object (ie, cascade deletes).

All the generated methods take more parameters to customize their behaviour to suit your needs.

## Defining Callbacks

Og provides a detailed callback facility allowing you to hook into a managed objects Lifecycle. This is a very useful feature that can improve your code considerably. To implement a callback, you have to define one or more of the following methods in your class:

```ruby
og_pre_insert
og_post_insert
og_pre_update
og_post_update
og_pre_insert_update
og_post_insert_update
self.og_pre_delete
```

For example, the following code defines a callback for the Post class.

```ruby
class Post
    ...

    def og_post_insert(conn)
        puts 'Hey, a new post was just posted!'
    end
end
```

When post.save is called, you will get this alert:

```ruby
p = Post.create('Hello')
=> console: Hey, a new post was just posted!
```

## Using OOP techniques

Og managed objects are standard Ruby objects, so we can use class inheritance and module inclusion to minimize the code we have to write. Heres how we can improve the blog schema:

```ruby
class Category
    property :name, String
    many_to_many :posts, Post

    def initialize(title = nil)
        @title = title
    end
end

class Common
    property :title, String, :sql => 'VARCHAR2(32) NOT NULL'
    property :body, String
    property :author, String
    property :create_time, Time

    def initialize(title = nil, body = nil, author = nil)
        @title, @body, @author = title, body, author
        @create_time = Time.now
    end
end

class Post < Common
    property :hits, Fixnum, :sql_index => true
    has_many :comments, Comment

    def initialize(title = nil, body = nil, author = nil)
        super
        @hits = 0
    end
end

class Comment < Common
    belongs_to :post, Post
end
```

In essence, this feature allows you to create SQL tables using inheritance, saving you lots of time when using objects with similar properties. Its also less error prone.

## Defining Validation Rules

When managing large amounts of data, enforcing data integrity is important. Og provides another domain specific mini language that allows you to define validation rules in a simple manner. In the following code, the blog schema is enriched with hints that allows Og to automatically generate validation code:

```ruby
class Common
    property :title, String, :sql => 'NOT NULL VARCHAR(32)'
    property :body, String
    property :author, String
    property :create_time, String

    validate_value :title
    validate_length :body, :range => 2..100, :msg_long => 'argh'
    validate_format :author, :format => /[a-z]/, :msg => 'wrong format'

    def initialize(title = nil, body = nil, author = nil)
        @title, @body, @author = title, body, author
        @create_time = Time.now
    end
end
```

This code demonstrates some validations facilities. Using the validate_value macro, we enforce that the title property will have a value. Using the validate_length macro, we enforce the minimum and maximum lengths for the body property. Using the validate_format macro, we enforce a required format for values assigned to the author field.

Lets see this validation in practice:

```ruby
c = Comment.new
c.valid?
=> false
c.errors.count
=> 3

c.title = 'Hello'
c.valid?
c.errors.count
=> 2
```

The errors array contains a list of Error objects that point to the offending field and contain a descriptive message.

With Og, you can customize almost everything! More information can be found in the source code (lib/glue/validation.rb). To whet your appetite, here is a list of predefined validation macros:

```ruby
validate_value
validate_format
validate_length
validate_inclusion
validate_confirmation
```

TypeMacros
If you look at the common class definition, you will notice that the :sql option looks kind of ugly:

```ruby
:sql => 'VARCHAR2(32) NOT NULL'
```

When building larger object models, this issue comes up frequently. Og provides a elegant solution in the form of type macros:

```ruby
def VarChar(size)
    return String, :sql => "VARCHAR2(#{size}) NOT NULL"
end

property :title, VarChar(30)
```

## Switching To Another Database

While Postgres is a great database, lets assume that the client wants to switch to MySQL at the last minute. Don't worry, Og can easily accommodate this by simply changing the db reference in the configuration file to look like this and then re-running the example:

```ruby
db = Og::Database.new(
    :database => 'test',
    :adapter  => 'mysql',
    :user     => 'postgres',
    :password => 'navelrulez'
)
```

A new MySQL database is automatically created along with all tables, indices, etc. You get all this with changing only one line of code!

## Is There More?

You betcha! You can to find more about Og by reading the available RDoc documentation and browsing the examples.

For any questions regarding Og, feel free to ask on the ruby-talk mailing list (which is mirrored to comp.lang.ruby).

A Nitro specific mailing list is also available. You can post questions about Og to this list. Please subscribe to nitro-general@rubyforge.com. The homepage for this list is available here:

<https://rubyforge.org/mailman/listinfo/nitro-general>

Note that Og is still under heavy development, so new features are being added frequently. Be sure to check back for updates.

**Update 2020**: Additional discussion:

<a href="https://www.reddit.com/r/programming/comments/bnuq/nitro_rails_is_not_the_only_web_programming/" target="_blank" rel="noopener">Rails is not the only web programming framework for Ruby</a>

**Update 2018**: Resurrected this text from archive.org, grammatical corrections.


September 21, 2020

May 21, 2020

April 14, 2018

February 18, 2015

October 3, 2014

August 21, 2014

August 7, 2014

August 5, 2014

August 4, 2014

August 3, 2014

September 18, 2011

March 17, 2011

February 4, 2011

October 18, 2010

September 27, 2010

August 28, 2010

August 9, 2010

June 23, 2010

April 22, 2010

February 7, 2010

January 21, 2010

July 23, 2009

July 8, 2009

February 7, 2009

December 24, 2008

November 13, 2008

October 29, 2008

September 30, 2008

July 7, 2007

June 16, 2007

April 23, 2007

February 19, 2007

February 10, 2007

February 7, 2007

January 30, 2007

January 29, 2007

January 27, 2007

January 26, 2007

January 22, 2007

January 19, 2007

January 9, 2007

December 19, 2006

November 16, 2006

March 2, 2005