arocks

It pretty well explained in their docs: https://docs.djangoproject.com/en/5.2/misc/design-philosophi...

No it really didn't help much. There are a number of reasons. A tip or a hack cannot solve what is essentially an emotion regulation problem. You probably don't procrastinate on all tasks. For example you can probably read reddit or play games all day. But you dread even starting some tasks. It might be due to multiple reason: past failures, critical feedbacks etc. You will need to introspect and solve that complicated emotion.

Of course, if you notice a broad pattern in every part of your life please consider professional help.

At the risk of tooting my own horn, here is a ray tracing tutorial series in Python: https://www.youtube.com/playlist?list=PL8ENypDVcs3H-TxOXOzwD...

https://chrome.google.com/webstore/detail/github-repository-...

I think this Chrome extension called "GitHub Repository Size" might be exactly what you are looking for

Countries like India are heavy users of diary products. Lactose intolerance is rare too. But always fare very poorly in the height rankings. So it cannot be concluded that it is diary products alone.

It is a great example "Worse is better"[1]. XML has a lot more functionality than JSON but very few people can fully understand all the X* family of specifications, whereas JSON is a _lot_ easier and handles majority of the use cases.

There are many, many real life situations where a developer needs to choose between using JSON, XML or YAML to store their configuration data, message formats etc. Simply stating that JSON is good only in one scenario and XML must be used in every other is over-simplification.

[1] https://www.dreamsongs.com/RiseOfWorseIsBetter.html

My biggest problem with these list making solutions are what I call the collateral tasks. For example, my list says "Buy a Christmas gift for Jen".

When I start shopping online, I realize that I don't know much about Jen, so I need to call a friend. Lots of discussion later, I finalize on something to buy then I need to think of a personal note to write.

At the checkout, my banking application tells me that my internet password needs to be changed. The whole process gets aborted!

Probably, I exaggerated a little but my point being that each task involves a million micro steps which may or may not be anticipated. No wonder there is a lot of procrastination!

I have seen sites using captchas which ask such visual questions thinking that only a human can answer them. This project really makes me doubt the effectiveness of such techniques.

Wasn't Burroughs B5000 the first computer to have all system software written in a high level language in the 1960s?

[1] https://en.wikipedia.org/wiki/Burroughs_large_systems#B5000

Actually using wheels on Windows is a superior solution for most packages now.

Another equally good simulator (built in Om, React): http://cmdrdats.github.io/undertype/

Even if you don't use Emacs, I believe you _have_ to try magit. It will quickly become an essential part of your git workflow. You could zoom out to grasp the overall state of your project, dive into specific details and perform intricate surgery of your git history, all with single-key presses. It is pure genius.

It seems most of the content is under "Standard YouTube Licence"[1]. Since this is historical footage I would have preferred if it was under Creative Commons, so that it could be included in other videos. Anyways, this makes YouTube even more useful for preserving and making notable videos more accessible.

[1] https://www.youtube.com/static?template=terms

Is it possible to use this for creating videos with motion graphics? Even the possibility of a frame by frame render would be awesome.

OnLive? [1]

[1] https://en.wikipedia.org/wiki/OnLive

If you liked this then you might find my Python one liner games interesting [1]. They fit a tweet in most cases.

[1] http://arunrocks.com/python-one-liner-games/

Right. Since you mention the installation instructions from Real World OCaml and the examples in the book need you to use Core, it is likely that beginners would experience these issues.

Thank you so much for writing this. It is useful not just for Emacs users but to anyone who prefers writing their book in a text-based markup rather than Microsoft Word. It also explains how to collaborate with someone who uses Word exclusively.

Unfortunately, every tool has a quirk and we eventually need to settle on a workflow that somehow works, even though everything might be open source as you have described in the case of Pandoc. But I believe Emacs is the best authoring tool for books due to its versatility.

It seems `int_of_float` and `float_of_int` are deprecated by the Jane Streets Core library. It even throws errors on utop. I believe they need to be replaced by `Int.of_float` and `Float.of_int` respectively.

EDIT: Some more corrections:

1. `List.hd []` doesn't raise an error as its return type is an option. So the result is a `None`.

2. `List.map` and `List.filter` arguments should be reversed. First argument should be a list and the second should be the mapping function.

While the article shows some really good performance improvements, the tone is really sensationalist. While challenging 'comparison demos' in leiu for proof, the author responds with... yet another comparison demo

The title is not entirely falsified either - ReactJS is fast out of the box. Other frameworks can be tuned to achieve comparable speeds. But in most cases, ReactJS still wins.

Sorry, you are right. I had meant to write pyglet as my preferred option.

This is an excellent option to teach programming to kids. Pygame has been always the recommended game library for Python due to its maturity. But Pygame had been my preferred option as it had less boilerplate and seemed more Pythonic. However, its project activity is quite low.

Pygame Zero seems like the best of both worlds.

...the time-tested Real World Haskell is now fairly outdated, but the more recent Beginning Haskell is perfectly relevant.

Wow, I was not aware of this.

It will surely work in Django 1.8. But whether the Django 1.8 recommendations like turning `urlpattern` into a list [1] or using `TEMPLATES` setting [2] have been applied is a different matter altogether.

[1] https://github.com/mineta/taskbuster-boilerplate/blob/master...

[2] https://github.com/mineta/taskbuster-boilerplate/blob/master...

I am glad that someone took the efforts to dig around and dispel these myths. But then even more important is the question - why we don't have enough evidence based scientific studies in the world of software?

My guess is that it is because no two software projects are alike. Differences stemming from differing technology stacks, to domains or people skills, it is practically impossible to generalize anything across them.

Unless we all standardize on a one true way of software engineering, such folklores will continue to exists and there will be a dearth in repeatable conclusions.

PS: However, I do agree with Laurent that we can work towards aggregating numbers from several real software projects than rely on unsubstantiated folklore.

The wiki platform itself, i.e. Kuma, is written on Django [1]. Along with KumaScript, the architecture is useful to understand how a modern wiki can be designed.

[1] https://developer.mozilla.org/en-US/docs/MDN/Kuma

The turtle widget [1] looks exactly like what I was looking for. It can be used to teach Python programming to kids within an IPython notebook.

[1] https://github.com/takluyver/mobilechelonian/tree/require-wi...

For those who don't know, there are several executable formats where smaller programs can be written. For instance, a .COM executable (a legacy format now [2]) can be written in just 20 bytes [1].

In the case of the Portable Executable (PE) format, 97 bytes is certainly an impressive feat.

[1] http://www.gnostice.com/nl_article.asp?id=225&t=The_Smallest...

[2] http://en.wikipedia.org/wiki/COM_file

If you are interested in a Bootstrap based theme, do check out Bootswatch Paper [1]. MUI is definitely a much lighter option though.

[1] http://bootswatch.com/paper/

I prefer Python's explicit approach to decimal types:

  $ python -c "from decimal import Decimal as D; print(D('.1')+D('.2')-D('.3'))"
  0.0

  $ python -c "from fractions import Fraction as F; print(F('.1')+F('.2')-F('.3'))"
  0

  $ python -c "from fractions import Fraction as F; print(F('3.1415927'))"
  31415927/10000000