molten is a minimal, extensible, fast and productive framework for building HTTP APIs with Python.

See how a minor change to your commit message style can make you a better programmer.

Format: <type>(<scope>): <subject>

where <scope> is optional.

Example
feat: add hat wobble
^--^  ^------------^
|     |
|     +-> Summary in present tense.
|
+-------> Type: chore, docs, feat, fix, refactor, style, or test.

More Examples:

• feat: new feature for the user, not a new feature for build script
• fix: bug fix for the user, not a fix to a build script
• docs: changes to the documentation
• style: formatting, missing semi colons, etc; no production code change
• refactor: refactoring production code, eg. renaming a variable
• test: adding missing tests, refactoring tests; no production code change
• chore: updating grunt tasks etc; no production code change

Adapted from http://www.possibility.com/Cpp/CppCodingStandard.html and NetBSD's style guidelines.

Line-breaking algorithms take a paragraph's-worth of words, and split the words into line-lengthed chunks. The two algorithms many programmer's know of are:

• The greedy algorithm; and,
• The Knuth-Plass algorithm (the 'latex one').

Most programmers "know" the following three facts:

• Knuth-Plass produces the 'best' line breaks;
• Knuth-Plass is a quadratic algorithm; and,
• Knuth-Plass uses dynamic programming and is impossible for mere mortals to code.

While we happen to agree with (1), we will demonstrate that (2) and (3) are, respectively, not true, and unnecessarily obscure. In fact, the Knuth-Plass algorithm---even in its most naive implementation---is strongly dominated by a light-weight linear run-time, and the implementation of the core algorithm is remarkably straightforward.

How many times have you repeatedly typed out a long command on the command line and wished there was a way to save it for later? This is where Bash aliases come in handy. They allow you to condense long, cryptic commands down to something easy to remember and use. Need some examples to get you started? No problem!

I recently built a small agent-based model using Python and wanted to visualize the model in action. But as much as Python is an ideal tool for scientific computation (numpy, scipy, matplotlib), it's not as good for dynamic visualization (pygame?).

You know what's a very mature and flexible tool for drawing graphics? The DOM! For simple graphics you can use HTML and CSS; for more complicated stuff you can use Canvas, SVG, or WebGL

A collection of design patterns/idioms in Python. Contribute to faif/python-patterns development by creating an account on GitHub.

I’ve been programming for 15 years now. Recently our industry’s lack of care for efficiency, simplicity, and excellence started really getting to me, to the point of me getting depressed by my own career and the IT in general.

Modern cars work, let’s say for the sake of argument, at 98% of what’s physically possible with the current engine design. Modern buildings use just enough material to fulfill their function and stay safe under the given conditions. All planes converged to the optimal size/form/load and basically look the same.

Only in software, it’s fine if a program runs at 1% or even 0.01% of the possible performance. Everybody just seems to be ok with it. People are often even proud about how much inefficient it is, as in “why should we worry, computers are fast enough”...

At the North America edition of the 2018
Linux Security Summit (LSS NA), which was held in late August in Vancouver,
Canada, Kees Cook gave a presentation on some of the dangers that come with
programs written in C. In particular, of course, the Linux kernel is
mostly written in C, which means that the security of our systems rests on
a somewhat dangerous foundation. But there are things that can be done to
help firm things up by "Making C Less Dangerous" as the title
of his talk suggested.

Brian Kernighan

Princeton University

July 13, 2009

Choosing a programming language for a project is a compromise over what you what you need, what you have, what you know and what you like. This post is just my thought process when selecting the implementation language for packnback.

What we need

• High performance, we will hopefully be dealing with large volumes of data.
• High security, the whole purpose is to protect data from attackers.
• Stability, software needs to be usable well into the future.
• Simplicity, the less complicated something is, the less that can go wrong.
• Popularity, this is mainly to help with marketing, libraries and community support.
• High bus factor, will sudden unexpected events destroy the language prospects.
• Fun, something we enjoy using or evaluating.

Let me preface this with an apology: this is a technology love story, and as such, it’s long, rambling, sentimental and personal. Also befitting a love story, it has a When Harry Met Sally feel to it, in that its origins are inauspicious…

A developer's guide about how to share code between Android and iOS with Kotlin Multiplatform.

Jupyter notebooks as Markdown documents, Julia, Python or R scripts.

Toolkit for Text Generation and Beyond. Contribute to asyml/texar development by creating an account on GitHub.

These Python libraries make it easy to scratch that personal project itch.