Ian Bicking

(i love the python community, esp the meetings at GOOG HQ. voidspace.org.uk (great dev, great mind, but the un-design, ooh) http://sayspy.blogspot.com/ http://blog.ianbicking.org/ http://jtauber.com/python/ blog.doughellmann.com

Absolutely right: Ian is one of the best Python programmers and technical writers ("blogger" just doesn't capture it) whose prose and code I've ever had the pleasure of reading and using for decades. (I'm still maintaining a TurboGears project using his SQLObject library even today, which I gleefully adopted as a traumatized Zope refugee.) If I had an open position worthy of his talents, I would move heaven and earth to work with him. https://ianbicking.org/events-and-sqlobject.html https://ianbicking.org/archive/sqlobject-and-me.html https://en.wikipedia.org/wiki/SQLObject Edit: In case you have "show dead" enabled, I'd like to add that smohare has no fucking clue what he's shit talking about, but by looking at his dead downvoted posting history and useless comments and worthless opinions, to be jealously insulted by him is the highest complement.

So Python 2 did not have super obvious string handling. One of the odd things that they seemingly could have fixed pretty easily is to change the default encoding from 'ascii' to 'utf8'. That would have fixed a bunch of the UnicodeDecodeErrors that were the most obvious problem with strings: http://www.ianbicking.org/illusive-setdefaultencoding.html If they had to make Python 3 anyway, I think the main thing they were missing is that they should have added a JIT. That makes upgrading to Python 3 a much easier argument. If the only point of the JIT was to add a selling point to Python 3, that probably would have been worth it.

A follow up post is http://www.ianbicking.org/where-smalltalk-went-wrong-2.html (via https://news.ycombinator.com/item?id=8797560).

You can get the best of all worlds imo by using lxml, which supports the selectors you want, uses Python which I prefer, and in my experience lxml is more robust than BeautifulSoup. I spent more than a year writing hundreds of scrapers that ran for weeks at a time. BeautifulSoup did not work out as well as lxml in practice. On extremely javascript heavy pages we used pyv8 actually. edit: more information at http://blog.ianbicking.org/2008/12/10/lxml-an-underappreciated-web-scr… the comments are useful too.

"PHP is stupidly simple to deploy compared to most other technologies" That's true, but it stops mattering for more complex sites where you want easy rollbacks to previous versions if a deploy went awry, separate static media serving (because it's faster), load balancing and the like. Nobody will dispute that PHP has by far the best deployment story if you need to quickstart something (see http://blog.ianbicking.org/2008/01/12/what-php-deployment-gets-right/)… But for an application of any complexity, really, you'll have more important stuff to worry about.

WebOb, Routes, SQLAlchemy, Mako. My favorite framework is no framework. The bottom line is that its a sliding scale. Django will give you a large amount of functionality for free but requires that you do things the Django way. As you move along the scale towards projects like Werkzeug you'll inevitably lose some of the free stuff but you'll be able to make a lot more choices on how things work. You'll want to check Ian Bicking's blog for some good reading on the no-framework approach. [1] is a great place to start. [1] http://blog.ianbicking.org/2010/03/12/a-webob-app-example/

"The Smalltalk image may seem unfamiliar or even scary at first, but it's really little different from a standard Ruby or Python process, except that it is serializable and contains all of the code (both compiled and in source form), data, and execution state as objects that you can manipulate." Well that's not very similar to a Ruby or Python process then, is it? And those processes are short lived and built from scratch on every execution. Anything you want to keep around you have to serialize and save explicitly. This is a painful but useful discipline. Perhaps an interesting analog, Docker emphasizes recreating over storing, while in normal sysadmin practice you update systems in place. In theory they can achieve the same results, but enforcing discipline makes a difference in practice. Smalltalk of course is code, and you can do whatever you want with it. And Smalltalk is delightful in many ways, I enjoyed it a great deal when I used it, and people using Smalltalk can be very productive when they have to recreate the world. But you have to recreate the world. And there's strong cultural drift. Lots of things are possible, but possibilities aren't enough to create a community of practice. Looking at files, I looked up "using git with smalltalk" and got the GitHub list of Smalltalk projects: https://github.com/trending?l=smalltalk – I look at one that has a couple contributors, find Cuis: https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev – it's got giant…

Ian Bicking does a great job of debunking the many of the alleged advantages of code sharing: http://blog.ianbicking.org/2011/03/30/js-on-server-and-client-is-not-a… Validation on the client is primarily a user experience concern, where you focus on bringing attention to problems with a form, and helping the user resolve those problems. Once the form is submitted, if you’ve done thorough client-side validation you can also avoid friendly server-side validation. Of course all your client-side validation could be avoided through a malicious client, but you don’t need to give a friendly error message in that case, you can simply bail out with a simple 400 Bad Request error. At that point there’s not much in common between these two kinds of validation — the client is all user experience, and the server is all data integrity.

I wrote about something along these lines 3 years ago, but used the name "Heisenfunctions," which I think is better :) https://kylekukshtel.com/incremental-determinism-heisenfunctions-gpt-f… A lot of this was also inspired by Ian Bicking's work here: https://ianbicking.org/blog/2023/01/infinite-ai-array.html

I found the post [0] to be a really interesting read, and as one susceptible to solipsism and the simulation hypothesis, this paragraph hit me hard: > My biggest difficulty was getting ChatGPT to understand the constraints of the game. It may have been harder because an LLM’s constraints are so close to a text adventure, and it is used to imagining something less constrained; like it couldn’t distinguish between its dream-state and the actual medium in which it exists. [O] https://ianbicking.org/blog/2025/07/intra-llm-text-adventure

Hi, maybe it was this one https://www.ianbicking.org/blog/2020/08/thoughts-on-voice-interfaces.h… Here’s also another post you might be interested in https://www.speechly.com/blog/real-time-voice-user-interfaces/

It is a sentiment that is shared by many: https://www.ianbicking.org/where-smalltalk-went-wrong-2.html For some people living in an environment/IDE works, other people feel locked in. It is certainly unusual if you are used to the Unix approach. Since there are so many languages and so little time, I would think that many people haven't tried Smalltalk at all because of this hurdle.

> Currently each high level language compiles to its own thing creating huge islands of code. C#, Java, Go, Rust, C etc will all compile their frameworks into the wasm files with very simple facade interfaces. This is more or less what SmallTalk has been doing for ages. The keyword for that is "image", in particular "single image". And yes, it poses interoperability problems: http://www.ianbicking.org/where-smalltalk-went-wrong.html

It's useful when you want a sentinel object and you don't want to use None as the sentinel because it is a valid value. Some discussion here: http://www.ianbicking.org/blog/2008/12/the-magic-sentinel.html

This wasn't without huge limitations. The image often is considered as a mistake ( http://www.ianbicking.org/where-smalltalk-went-wrong.html )

not really 'small', but some of the Python related blogs I follow are: - http://pycon.blogspot.in/ - http://lucumr.pocoo.org/ - http://inventwithpython.com/blog/ - http://www.blog.pythonlibrary.org/ - http://www.ianbicking.org/blog/ - http://www.binarytides.com/ - http://www.peterbe.com/ - http://viksalgorithms.blogspot.com/ - http://rz.scale-it.pl - http://packetforger.wordpress.com/ - http://blog.pythonisito.com/

wth is going on at mozilla? There seems to be a lot of excitement to create stuff, without much attention to whether it's needed .. or where the lifecycle goes beyond creation. http://www.ianbicking.org/blog/2014/09/professional-transitions.html

Yeah. http://www.ianbicking.org/blog/2014/09/professional-transitions.html "It’s a little hard to tell – I guess we didn’t actually shutter anything, and though it was announced internally it is entirely unclear externally. But Mozilla Labs is definitely shut down."

Some of Raskin's idea is really like what Emacs does. Ian Bicking once wrote an article THE vs. Emacs. http://blog.ianbicking.org/the-vs-emacs.html

Python specific advice on re-raising upon catching and keeping the original trace: in Python 2.7+, please use chained exceptions: http://www.python.org/dev/peps/pep-3134/ For older Python versions please see http://blog.ianbicking.org/2007/09/12/re-raising-exceptions/

> For older Python versions please see http://blog.ianbicking.org/2007/09/12/re-raising-exceptions/ This is super important, I recently rediscovered this with a colleague (the company's tool was fucking up exceptions everywhere, either over-logging things or throwing stacktraces out in an attempt to rewrap them and we decided to fix this). Although the second-to-last example: new_exc = Exception("Error in line %s: %s" % (lineno, exc or exc_class)) raise new_exc.__class__, new_exc, tb would be much better written as: raise Exception, "Error in line %s: %s" % (lineno, exc or exc_class), tb

This blog post is essential reading for Python developers who see doctest.js and think "ew, doctest": http://blog.ianbicking.org/2012/10/02/why-doctest-js-is-better-than-py…

There are lots of people that agree with you: http://www.plope.com/Members/chrism/pythonic I preferred what Ian Bicking wrote in response: http://blog.ianbicking.org/unzen-of-unpython.html One thing I like about the Django community is that part of Djangocon specifically features critics who are invited to criticize Django or some aspect of it, for example: "Why Django Sucks and how we can fix it" http://blip.tv/djangocon/why-django-sucks-and-how-we-can-fix-it-413130… Flasky Goodness (or Why Django Sucks?) http://reinout.vanrees.org/weblog/2012/06/06/flask-django-sucks.html That's much better and productive than circling the wagons and letting personal insults fly.

For another clever take on mocking in Python, check out Ian Bicking's minimock: http://blog.ianbicking.org/minimock.html

Yeah, as http://blog.ianbicking.org/2008/01/12/what-php-deployment-gets-right/ spells out in depth.

Also, long ago there was Prothon, which wasn't exacyly python but was very close, and didn't have a GIL. Unfortunately, it seems all source code drops of this disappeared from the earth, though you can still find some mentions e.g. http://blog.ianbicking.org/initial-thoughts-on-prothon.html I don't remember how Vyper worked, but it might have abolished the GIL too: http://got.net/~landauer/sw/vyper_readme.html

In my experiments (http://blog.ianbicking.org/2008/03/30/python-html-parser-performance/) lxml performed better than cElementTree for memory -- notably cElementTree creates Python objects for all nodes, while lxml does so only on demand (though I suppose if you ultimately touch every node in Python then lxml will use more memory). Also lxml preserves the namespace prefixes, which while formally not necessary to understand a document are often in practice both aesthetic and sometimes necessary (e.g., RDF). Also algorithmically, I find lxml's parent pointer on nodes to be very handy. I find some things really really hard in ElementTree because you can't directly get the parent of a node.

How relevant are these posts now? http://blog.ianbicking.org/2008/12/10/lxml-an-underappreciated-web-scr… http://blog.ianbicking.org/2008/03/30/python-html-parser-performance/