The make Allegro better project

The make Allegro better project

kazzmir

Member #1,786

December 2001

Id like to try an experiment. I think the Allegro source could be refactored somewhat and made more elegant so I propose that the community rewrites portions of Allegro. I( or anyone really ) will post a function or other snippet of code from Allegro and people can modify it in any way as long as its "better", be it by choosing better variable names or simply adding useful comments. For now the code will come from 4.2 since 4.3 isn't ready for mass consumption.

After people agree on the changes it will be sent to the Allegro developers list and if approved will be committed.

And if it needs justification I would say there are two main benefits.
1) Some parts of Allegro are extremely hard to follow
2) More people would become more intimate with the internals to Allegro

Ill start off with the gourad sprite routine in gsprite.c. I havent yet refactored this one, Ill post some modifications later on.

1/* draw_gouraud_sprite:
*  Draws a lit or tinted sprite, interpolating the four corner colors
*  over the surface of the image.
*/
5void _soft_draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int c1, int c2, int c3, int c4)
6{
 fixed mc1, mc2, mh;
 fixed lc, rc, hc;
 int x1 = x;
 int y1 = y;
 int x2 = x + sprite->w;
 int y2 = y + sprite->h;
 int i, j;
 int pixel;
 uintptr_t addr;
16 
 ASSERT(bmp);
 ASSERT(sprite);
 ASSERT(bmp->vtable->color_depth == sprite->vtable->color_depth);
20 
 bmp_select(bmp);
22 
 /* set up vertical gradients for left and right sides */
 mc1 = itofix(c4 - c1) / sprite->h;
 mc2 = itofix(c3 - c2) / sprite->h;
 lc = itofix(c1);
 rc = itofix(c2);
28 
 /* check clipping */
 if (bmp->clip) {
    if (y1 < bmp->ct) {
 lc += mc1 * (bmp->ct - y1);
 rc += mc2 * (bmp->ct - y1);
 y1 = bmp->ct;
    }
    y2 = MIN(y2, bmp->cb);
    x1 = MAX(x1, bmp->cl);
    x2 = MIN(x2, bmp->cr);
 }
40 
 for (j=y1; j<y2; j++) {
    /* set up horizontal gradient for line */
    mh = (rc - lc) / sprite->w;
    hc = lc;
45 
    /* more clip checking */
    if ((bmp->clip) && (x < bmp->cl))
 hc += mh * (bmp->cl - x);
49 
 #ifdef GFX_HAS_VGA
51 
    /* modex version */
    if (is_planar_bitmap(bmp)) {
 addr = ((unsigned long)bmp->line[j]<<2) + x1;
 for (i=x1; i<x2; i++) {
    if (sprite->line[j-y][i-x]) {
       outportw(0x3C4, (0x100<<(i&3))|2);
       pixel = color_map->data[fixtoi(hc)][sprite->line[j-y][i-x]];
       bmp_write8(addr>>2, pixel);
    }
    hc += mh;
    addr++;
 }
    }
    else {
66 
 #else
68 
    {
70 
 #endif
72 
 /* draw routines for all linear modes */
 switch (bitmap_color_depth(bmp)) {
75 
 #ifdef ALLEGRO_COLOR8
77 
    case 8:
       addr = bmp_write_line(bmp, j) + x1;
       for (i=x1; i<x2; i++) {
    if (sprite->line[j-y][i-x]) {
       pixel = color_map->data[fixtoi(hc)][sprite->line[j-y][i-x]];
       bmp_write8(addr, pixel);
    }
    hc += mh;
    addr++;
       }
       break;
89 
 #endif
91 
 #ifdef ALLEGRO_COLOR16
93 
    case 15:
    case 16:
       addr = bmp_write_line(bmp, j) + x1*sizeof(short);
       for (i=x1; i<x2; i++) {
    pixel = ((unsigned short *)sprite->line[j-y])[i-x];
    if (pixel != bmp->vtable->mask_color) {
       if (bitmap_color_depth(bmp) == 16)
    pixel = _blender_func16(pixel, _blender_col_16, fixtoi(hc));
       else
    pixel = _blender_func15(pixel, _blender_col_15, fixtoi(hc));
       bmp_write16(addr, pixel);
    }
    hc += mh;
    addr += sizeof(short);
       }
       break;
110 
 #endif
112 
 #ifdef ALLEGRO_COLOR24
114 
    case 24:
       addr = bmp_write_line(bmp, j) + x1*3;
       for (i=x1; i<x2; i++) {
    bmp_select(sprite);
    pixel = bmp_read24((unsigned long)(sprite->line[j-y] + (i-x)*3));
    bmp_select(bmp);
    if (pixel != MASK_COLOR_24) {
       pixel = _blender_func24(pixel, _blender_col_24, fixtoi(hc));
       bmp_write24(addr, pixel);
    }
    hc += mh;
    addr += 3;
       }
       break;
129 
 #endif
131 
 #ifdef ALLEGRO_COLOR32
133 
    case 32:
       addr = bmp_write_line(bmp, j) + x1*sizeof(int32_t);
       for (i=x1; i<x2; i++) {
    pixel = ((unsigned long *)sprite->line[j-y])[i-x];
    if (pixel != MASK_COLOR_32) {
       pixel = _blender_func32(pixel, _blender_col_32, fixtoi(hc));
       bmp_write32(addr, pixel);
    }
    hc += mh;
    addr += sizeof(int32_t);
       }
       break;
146 
 #endif
148 
 }
    }
151 
    lc += mc1;
    rc += mc2;
 }
155 
 bmp_unwrite_line(bmp);
157}

Andrei Ellman

Member #3,434

April 2003

I just thought that this would be a good time to post a link to the Allegro coding standards (it's the 'coding style' section) so that we know how to rename the variables/functions, and how to format the code, etc.

AE.

--
Don't let the illegitimates turn you into carbon.

Elias

Member #358

May 2000

Note that we do not follow the tab standard described there anymore: Any new code should not contain any tab characters.

About the original idea, it sounds good to me. Also, improving documentation of how Allegro works internaly could be a good idea.. like a description how drivers work together, and how single drivers (e.g. DirectX) actually work.

Hm, and not sure how well this all can work for 4.3 as of yet, as some very base structures like AL_SYSTEM_DRIVER, AL_DISPLAY or AL_BITMAP are not implemented yet.

--
"Either help out or stop whining" - Evert

kazzmir

Member #1,786

December 2001

Quote:

Hm, and not sure how well this all can work for 4.3 as of yet, as some very base structures like AL_SYSTEM_DRIVER, AL_DISPLAY or AL_BITMAP are not implemented yet.

Thats why I think we should focus on 4.2 for now and only the parts of the code that can be used in 4.3 so the work isnt wasted once 4.2 isnt worked on anymore.

[edit]
Here is my first modification. Mostly I just renamed variables and added some comments at the top. I noticed that the old 'x' variable was being referenced in the code but since x1 = x I thought x1 should have been used instead so the parameter x is now x_ so we can be sure its not used accidentally. The same for y.

1/* draw_gouraud_sprite:
*  Draws a lit or tinted sprite, interpolating the four corner colors
*  over the surface of the image.
*  destination - BITMAP where the sprite will be drawn to
*  sprite - BITMAP of the sprite to draw
*  x_ - upper left hand x coordinate on destination
*  y_ - upper left hand y coordinate on destination
*  color1 - upper left hand color
*  color2 - upper right hand color
*  color3 - lower left hand color
*  color4 - lower right hand color
*/
13void _soft_draw_gouraud_sprite(BITMAP * destination, BITMAP *sprite, int x_, int y_, int color1, int color2, int color3, int color4)
14{
 double gradient1;
 double gradient2;
 double left_dx;
 double right_dx;
 int x1 = x_;
 int y1 = y_;
 int x2 = x_ + sprite->w;
 int y2 = y_ + sprite->h;
 int i, current_y;
 int pixel;
 uintptr_t addr;
26 
 ASSERT(destination);
 ASSERT(sprite);
 ASSERT(destination->vtable->color_depth == sprite->vtable->color_depth);
30 
 bmp_select(destination);
32 
 /* set up vertical gradients for left and right sides */
 gradient1 = (color4 - color1) / sprite->h;
 gradient2 = (color3 - color2) / sprite->h;
 left_dx = color1;
 right_dx = color2;
38 
 /* check clipping */
 if (destination->clip) {
    if (y1 < destination->ct) {
 left_dx += gradient1 * (destination->ct - y1);
 right_dx += gradient2 * (destination->ct - y1);
 y1 = destination->ct;
    }
    y2 = MIN(y2, destination->cb);
    x1 = MAX(x1, destination->cl);
    x2 = MIN(x2, destination->cr);
 }
50 
 for (current_y=y1; current_y<y2; current_y++) {
    /* set up horizontal gradient for line */
    double horizontal_gradient = (right_dx - left_dx) / sprite->w;
    double color = left_dx;
55 
    /* more clip checking */
    if ((destination->clip) && (x1 < destination->cl)) {
 color += horizontal_gradient * (destination->cl - x1);
    }
60 
 #ifdef GFX_HAS_VGA
62 
    /* modex version */
    if (is_planar_bitmap(destination)) {
 addr = ((unsigned long)destination->line[current_y]<<2) + x1;
 for (i=x1; i<x2; i++) {
    if (sprite->line[current_y-y1][i-x1]) {
       outportw(0x3C4, (0x100<<(i&3))|2);
       pixel = color_map->data[(int)color][sprite->line[current_y-y1][i-x1]];
       bmp_write8(addr>>2, pixel);
    }
    color += horizontal_gradient;
    addr++;
 }
    }
    else {
77 
 #else
79 
    {
81 
 #endif
83 
 /* draw routines for all linear modes */
 switch (bitmap_color_depth(destination)) {
86 
 #ifdef ALLEGRO_COLOR8
88 
    case 8:
       addr = bmp_write_line(destination, current_y) + x1;
       for (i=x1; i<x2; i++) {
    if (sprite->line[current_y-y1][i-x1]) {
       pixel = color_map->data[(int)color][sprite->line[current_y-y1][i-x1]];
       bmp_write8(addr, pixel);
    }
    color += horizontal_gradient;
    addr++;
       }
       break;
100 
 #endif
102 
 #ifdef ALLEGRO_COLOR16
104 
    case 15:
    case 16:
       addr = bmp_write_line(destination, current_y) + x1*sizeof(short);
       for (i=x1; i<x2; i++) {
    pixel = ((unsigned short *)sprite->line[current_y-y1])[i-x1];
    if (pixel != destination->vtable->mask_color) {
       if (bitmap_color_depth(destination) == 16)
    pixel = _blender_func16(pixel, _blender_col_16, (int)color );
       else
    pixel = _blender_func15(pixel, _blender_col_15, (int)color );
       bmp_write16(addr, pixel);
    }
    color += horizontal_gradient;
    addr += sizeof(short);
       }
       break;
121 
 #endif
123 
 #ifdef ALLEGRO_COLOR24
125 
    case 24:
       addr = bmp_write_line(destination, current_y) + x1*3;
       for (i=x1; i<x2; i++) {
    bmp_select(sprite);
    pixel = bmp_read24((unsigned long)(sprite->line[current_y-y1] + (i-x1)*3));
    bmp_select(destination);
    if (pixel != MASK_COLOR_24) {
       pixel = _blender_func24(pixel, _blender_col_24, (int)color );
       bmp_write24(addr, pixel);
    }
    color += horizontal_gradient;
    addr += 3;
       }
       break;
140 
 #endif
142 
 #ifdef ALLEGRO_COLOR32
144 
    case 32:
       addr = bmp_write_line(destination, current_y) + x1*sizeof(int32_t);
       for (i=x1; i<x2; i++) {
    pixel = ((unsigned long *)sprite->line[current_y-y1])[i-x1];
    if (pixel != MASK_COLOR_32) {
       pixel = _blender_func32(pixel, _blender_col_32, (int)color );
       bmp_write32(addr, pixel);
    }
    color += horizontal_gradient;
    addr += sizeof(int32_t);
       }
       break;
157 
 #endif
159 
 }
    }
162 
    left_dx += gradient1;
    right_dx += gradient2;
 }
166 
 bmp_unwrite_line(destination);
168}

Evert

Member #794

November 2000

I think this is a nice way to encourage more people to have a look at and work on Allegro.
I'm not sure I fully agree that cosmetic rewrites are nescessarily a good thing, because it will clutter the change log and make it harder to go back to older revisions (which is why tab characters haven't been purged in one big sweep a while back). That doesn't nescessarily involve comment blocks or top line comments though. Anyway, we'll see how it goes, I suppose...

Peter Wang

Member #23

April 2000

I am all for getting more people involved with Allegro, but this is silly. Work on 4.3 instead. There's plenty to do.

kazzmir

Member #1,786

December 2001

For the changelog a single line description would suffice:

The following functions were changed cosmetically: foo, bar, baz

Quote:

I am all for getting more people involved with Allegro, but this is silly. Work on 4.3 instead. There's plenty to do.

4.3 is still under design and while it would be great to have more opinions on the design thats not something many people can readily contribute to simply because its fairly difficult and you already have to have a deep understanding of Allegro to do so.

I thought people would be interested to simply rewrite code so that it looks better and potentially spot any bugs. So far no one has done so, maybe its too early or its Sunday, I dont know.

Shouldnt Allegro strive to be perfect in every way?

Peter Wang

Member #23

April 2000

Quote:

The following functions were changed cosmetically: foo, bar, baz

Evert is talking about tracing when lines were last changed, e.g. using `svn annotate'. Large scale cosmetic changes mess that up for dubious value.

Btw, it takes far too much energy on this forum to check what changes have been made, and whether anything was broken. All I can tell is that you've renamed some variables and added whitespace where there shouldn't be.

         pixel = _blender_func24(pixel, _blender_col_24, (int)color );

Patching, verifying and committing will take even more energy. Count me out.

kazzmir

Member #1,786

December 2001

Well heres my last attempt for the night. Unfortunately its about 5 times slower than the current version, mostly because all the macros have been wrapped into functions. Of course I wouldnt want to slow down any functions so if there are any ideas how to speed this generic version up Id appreciate it.

1/* select a line from the bitmap for direct memory access
*/
3static uintptr_t get_line( BITMAP * bitmap, int y, int x ){
switch (bitmap_color_depth(bitmap)) {
  case 8:
    return bmp_write_line(bitmap, y) + x;
  case 15:
  case 16:
    return bmp_write_line(bitmap, y) + x*sizeof(short);
  case 24:
    return bmp_write_line(bitmap, y) + x*3;
  case 32:
    return bmp_write_line(bitmap, y) + x*sizeof(int32_t);
  default:
    return 0;
}
17}
18 
19/* read one pixel from the line pointer
*/
21static int read_pixel( BITMAP * bitmap, int y, int x ){
switch (bitmap_color_depth(bitmap)) {
  case 8:
       return bitmap->line[y][x];
  case 15:
  case 16:
       return ((unsigned short *)bitmap->line[y])[x];
  case 24:
       return bmp_read24((uintptr_t)(bitmap->line[y] + x*3));
  case 32:
       return ((unsigned long *)bitmap->line[y])[x];
  default:
         return 0;
}
35}
36 
37static void write_pixel( BITMAP * bitmap, uintptr_t address, int pixel ){
switch (bitmap_color_depth(bitmap)) {
  case 8:
    bmp_write8(address, pixel);
    break;
  case 15:
  case 16:
    bmp_write16(address, pixel);
    break;
  case 24:
    bmp_write24(address, pixel);
  case 32:
    bmp_write32(address, pixel);
}
51}
52 
53/* return the size of 1 pixel in the line pointer
*/
55static int get_address_size( BITMAP * bitmap ){
switch (bitmap_color_depth(bitmap)) {
  case 8:
    return 1;
  case 15:
  case 16:
    return sizeof(short);
  case 24:
    return 3;
  case 32:
    return sizeof(int32_t);
  default:
    return 1;
}
69}
70 
71/* this blender returns the pixel original value
*/
73static unsigned long blender_color_map( unsigned long x, unsigned long y, unsigned long n ){
return color_map->data[n][x];
75}
76 
77/* find the correct blender for the given color depth
*/
79static BLENDER_FUNC get_blender( BITMAP * bitmap ){
switch (bitmap_color_depth(bitmap)) {
  case 8:
    return blender_color_map;
  case 15:
    return _blender_func15;
  case 16:
    return _blender_func16;
  case 24:
    return _blender_func24;
  case 32:
    return _blender_func32;
  default:
    return blender_color_map;
}
94}
95 
96static int get_blender_color( BITMAP * bitmap ){
switch (bitmap_color_depth(bitmap)) {
  case 8: return 0;
  case 15: return _blender_col_15;
  case 16: return _blender_col_16;
  case 24: return _blender_col_24;
  case 32: return _blender_col_32;
  default: return 0;
}
105}
106 
107/* generic method for drawing one line of a gouraud shaded sprite
*/
109static void do_gouraud_line( BITMAP * destination, BITMAP * sprite, int dest_y, int sprite_y, int x1, int x2, double color, double horizontal_gradient ){
uintptr_t addr = get_line( destination, dest_y, x1 );
int address_size = get_address_size( destination );
int i;
int pixel;
BLENDER_FUNC blender = get_blender( destination );
int blender_color = get_blender_color( destination );
for (i=x1; i<x2; i++) {
  bmp_select(sprite);
  pixel = read_pixel(sprite,sprite_y,i-x1);
  if ( pixel != destination->vtable->mask_color ) {
    pixel = blender(pixel, blender_color, (int)color );
    bmp_select(destination);
    write_pixel(destination, addr, pixel);
  }
  color += horizontal_gradient;
  addr += address_size;
}
127}
128 
129/* draw_gouraud_sprite:
*  Draws a lit or tinted sprite, interpolating the four corner colors
*  over the surface of the image.
*  destination - BITMAP where the sprite will be drawn to
*  sprite - BITMAP of the sprite to draw
*  x_ - upper left hand x coordinate on destination
*  y_ - upper left hand y coordinate on destination
*  color1 - upper left hand color
*  color2 - upper right hand color
*  color3 - lower left hand color
*  color4 - lower right hand color
*/
141void _soft_draw_gouraud_sprite(BITMAP * destination, BITMAP *sprite, int x_, int y_, int color1, int color2, int color3, int color4)
142{
 double gradient1;
 double gradient2;
 double left_dx;
 double right_dx;
 int x1 = x_;
 int y1 = y_;
 int x2 = x_ + sprite->w;
 int y2 = y_ + sprite->h;
 int i, current_y;
 int pixel;
 uintptr_t addr;
154 
 ASSERT(destination);
 ASSERT(sprite);
 ASSERT(destination->vtable->color_depth == sprite->vtable->color_depth);
158 
 bmp_select(destination);
160 
 /* set up vertical gradients for left and right sides */
 gradient1 = (color4 - color1) / sprite->h;
 gradient2 = (color3 - color2) / sprite->h;
 left_dx = color1;
 right_dx = color2;
166 
 /* check clipping */
 if (destination->clip) {
    if (y1 < destination->ct) {
 left_dx += gradient1 * (destination->ct - y1);
 right_dx += gradient2 * (destination->ct - y1);
 y1 = destination->ct;
    }
    y2 = MIN(y2, destination->cb);
    x1 = MAX(x1, destination->cl);
    x2 = MIN(x2, destination->cr);
 }
178 
 for (current_y=y1; current_y<y2; current_y++) {
    /* set up horizontal gradient for line */
    double horizontal_gradient = (right_dx - left_dx) / sprite->w;
    double color = left_dx;
183 
    /* more clip checking */
    if ((destination->clip) && (x1 < destination->cl)) {
 color += horizontal_gradient * (destination->cl - x1);
    }
188 
 #ifdef GFX_HAS_VGA
190 
    /* modex version */
    if (is_planar_bitmap(destination)) {
 addr = ((unsigned long)destination->line[current_y]<<2) + x1;
 for (i=x1; i<x2; i++) {
    if (sprite->line[current_y-y1][i-x1]) {
       outportw(0x3C4, (0x100<<(i&3))|2);
       pixel = color_map->data[(int)color][sprite->line[current_y-y1][i-x1]];
       bmp_write8(addr>>2, pixel);
    }
    color += horizontal_gradient;
    addr++;
 }
    }
    else {
205 
 #else
207 
    {
209 
 #endif
      do_gouraud_line( destination, sprite, current_y, current_y - y1, x1, x2, color, horizontal_gradient );
    }
213 
    left_dx += gradient1;
    right_dx += gradient2;
 }
217 
 bmp_unwrite_line(destination);
219}

HoHo

Member #4,534

April 2004

Quote:

Unfortunately its about 5 times slower than the current version

Forcing inlining might help but I'm not too sure about this.

In general I agree with Peter Wang. 4.2 series is pretty much "done" and all energy should go to 4.3. Most people don't know anything about Allegro source anyway so for them it doesn't matter much if they work on 4.2 or 4.3. Perhaps only 4.3 is a bit easier because of less garbage.

__________
In theory, there is no difference between theory and practice. But, in practice, there is - Jan L.A. van de Snepscheut
MMORPG's...Many Men Online Role Playing Girls - Radagar
"Is Java REALLY slower? Does STL really bloat your exes? Find out with your friendly host, HoHo, and his benchmarking machine!" - Jakub Wasilewski

Fiddler

Member #5,385

January 2005

HoHo said:

For 4.3 the problem is that little is known about what has to be done, what is already there, what is currently being worked on etc.

I am sure that if some specific tasks were posted in allegro.cc (for example: "implement the joystick driver for X") it would attract developers. If even one or two people responded and started contributing more seriously it would be worth it IMHO.

However, this means that a more or less finalised API is needed, at least for the core (event queues, error handling, driver API, I don't know what else). Unless this has been stabilized and made public somewhere, there is very little a non-developer can do to help.

The Open Toolkit: a game development library for .Net/Mono.
http://www.opentk.com

Peter Wang

Member #23

April 2000

Ok, then. If anyone wants to finish off the mouse API and implementation, especially the Windows implementation, please tell me. It's sitting in a Subversion branch at the moment (I just need to merge the latest 4.3.0 changes into it). Any takers?

Also, it would be nice to have a force feedback API. Probably it will be a rather thin wrapper around whatever DirectX provides. Anyone with such a device want to work on that?

Chris Robinson has half a sound API designed and prototyped (if I remember). This would be quite a nice modular task to work on, I think.

The Mac port needs attention. Contact Peter Hull.

Thomas is working on his file hooks.

And then there's the display and graphics API... Elias and Evert seem to be jointly in charge of this. We were just discussing it recently on [AD].

gnolam

Member #2,030

March 2002

Are there actually any API (proposal) documents anywhere?

--
Move to the Democratic People's Republic of Vivendi Universal (formerly known as Sweden) - officially democracy- and privacy-free since 2008-06-18!

Fiddler

Member #5,385

January 2005

Take a look at the Allegro Wiki: http://awiki.tomasu.org/bin/view Although it seems it has been hit by spam bots recently, there is quite a lot of useful information there.

Also, the Allegro 5 documents (I think there is a link in the wiki to them). However, I don't think these are followed closely, if at all.

The Open Toolkit: a game development library for .Net/Mono.
http://www.opentk.com

Evert

Member #794

November 2000

Quote:

However, I don't think these are followed closely, if at all.

It's certainly the idea that they're followed at least somewhat. I should point out though that some of the details were left blank or undecided in them.
It makes no sense to reinvent the wheel and try to come up with a new design if so much time, skill and discussion went into the existing documents.

Andrei Ellman

Member #3,434

April 2003

Actually, I think that the Allegro source could do with some more comments and clearer variable names. Although I think that re-writing the algorithms to be more readable, yet slower is going a bit too far. I recently fixed a bug in the Grabber, and found that I would have fixed it much faster had the source been more commented. Having a well-commented source would encourage more people to fiddle around with it.

Also, while we're on the subject of adding comments to Allegro source, now would be a good time to discuss the possibility of using a self-documenting sourcecode-comments based form of documentation such as Doxygen as a replacement for the current ._tx format. When I mentioned this on the [AD] list recently, I was told that Doxygen (along with it's alternatives) had already been discussed, so if anyone could link to the discussion, that would be appreciated.

The web page for Doxygen is at http://www.stack.nl/~dimitri/doxygen/, and a liat of alternatives is here

AE.

--
Don't let the illegitimates turn you into carbon.

kazzmir

Member #1,786

December 2001

Did this get sent to the top or something? Anyway, I havent done much with this because I was waiting for 4.2.1 to come out.

About doxygen, I have no idea. It sounds nice, but the allegro docs are already so well written!

Thomas Fjellstrom

Member #476

June 2000

Quote:

Although it seems it has been hit by spam bots recently

Fixed all the ones I could find.

Please people, if you find any, TELL ME.

--
Thomas Fjellstrom - [website] - [email] - [Allegro Wiki] - [Allegro TODO]
"If you can't think of a better solution, don't try to make a better solution." -- weapon_S
"The less evidence we have for what we believe is certain, the more violently we defend beliefs against those who don't agree" -- https://twitter.com/neiltyson/status/592870205409353730